---
name: orthogonal-anyapi
description: "Call AnyAPI through Orthogonal's pay-per-use Run API: One API for hundreds of data operations: web search, scraping, social media profiles and posts (TikTok, Instagram, LinkedIn, X, YouTube and more), person and company enrichment, email finding and verification. Each operation takes normalized JSON input and returns a normalized result with its USD cost."
---

# AnyAPI — Orthogonal API

> Pay-per-use API on Orthogonal. Each call is billed to your Orthogonal balance.
> Base API: `https://api.orthogonal.com/v1/run` · [llms.txt](https://www.orthogonal.com/llms.txt) · [browse all APIs](https://www.orthogonal.com/catalog)

One API for hundreds of data operations: web search, scraping, social media profiles and posts (TikTok, Instagram, LinkedIn, X, YouTube and more), person and company enrichment, email finding and verification. Each operation takes normalized JSON input and returns a normalized result with its USD cost.

**Verified:** yes

## Access

**Run API:** `POST https://api.orthogonal.com/v1/run`
**Auth:** `Authorization: Bearer $ORTHOGONAL_API_KEY`
Get an API key at https://www.orthogonal.com/account/keys

No account or key yet? Set up Orthogonal first with https://www.orthogonal.com/skill.md: it covers the CLI, the MCP server, the TypeScript SDK and sign-up, including an agent sign-up without a password (https://www.orthogonal.com/agent-signup.md).

Every call goes through the unified Run API: send the API `slug`, the endpoint `path`, and the `query`/`body` parameters. The response is `{ "success": true, "priceCents": <US cents>, "requestId": "...", "data": { ... } }`.

Quote first, free: the same request with `"dryRun": true` returns the price without calling the API or charging anything. On a retry after a timeout, send the same `Idempotency-Key` header so the call runs and bills once.

## Endpoints

### Facebook Ad Creative Details

Pull one Meta Ad Library ad with its creative: every carousel variant, image and video URL, headline, body, and call to action.

**Price:** billed per result - \$4.62 per 1,000 requests base + \$0.00 per 1,000 results, capped at \$4.62 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Facebook Ad Creative Details pricing and uptime](https://getanyapi.com/api/facebook/ad-details-full) - live USD price, lane routing, and measured 30-day uptime. [Every Facebook endpoint](https://getanyapi.com/api/facebook).

`POST /v1/run/facebook.ad_details_full`

**Cost:** Up to $0.004077 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.004077 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/b5d66be4-86fe-4239-9157-43777a5f3a1e

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `id` | string | Yes | Meta Ad Library ad ID - the numeric id in an Ad Library URL (e.g. "962050096457659" from https://www.facebook.com/ads/library/?id=962050096457659). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/facebook.ad_details_full","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","id":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### RedNote (Xiaohongshu) Search

Search RedNote (Xiaohongshu) notes by keyword and return normalized note records with pagination.

**Price:** \$12.00 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [RedNote (Xiaohongshu) Search pricing and uptime](https://getanyapi.com/api/rednote/search) - live USD price, lane routing, and measured 30-day uptime. [Every Rednote endpoint](https://getanyapi.com/api/rednote).

`POST /v1/run/rednote.search`

**Cost:** Up to $0.01308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.01308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/ad0a3c70-4bc3-481f-b0cd-a695480087fa

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Pagination cursor from the previous response. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Keyword to search for on RedNote (Xiaohongshu). |
| `sort` | string | No | Sort order for matching notes. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/rednote.search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","sort":"<string>","source":"<string>"}}'
```

### GitHub User Pull Requests

List a GitHub user's public pull requests by handle (title, repository, state, creation date, and URL) with optional date filtering and pagination.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [GitHub User Pull Requests pricing and uptime](https://getanyapi.com/api/github/user-pull-requests) - live USD price, lane routing, and measured 30-day uptime. [Every Github endpoint](https://getanyapi.com/api/github).

`POST /v1/run/github.user_pull_requests`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/b6a2a0de-e6e3-4d74-a7ba-5f1984ec82d1

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Pagination cursor from a previous response (page number, defaults to 1). |
| `handle` | string | Yes | GitHub username. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `since` | string | No | Only include pull requests created on or after this date (YYYY-MM-DD). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `until` | string | No | Only include pull requests created on or before this date (YYYY-MM-DD). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/github.user_pull_requests","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","handle":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","since":"<string>","source":"<string>","until":"<string>"}}'
```

### GitHub Repository Contributors

List the people who have committed to a GitHub repository by repository URL, ordered by number of commits, with each contributor's login, profile URL and commit count. Look each one up with github.user for their profile, website and socials.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [GitHub Repository Contributors pricing and uptime](https://getanyapi.com/api/github/repository-contributors) - live USD price, lane routing, and measured 30-day uptime. [Every Github endpoint](https://getanyapi.com/api/github).

`POST /v1/run/github.repository_contributors`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/626cedff-4dc2-485d-b892-4ee939f116e5

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Rows per page, 1-100 (GitHub's own page-size limit). Keep it the same while walking pages, because it sets the page size. |
| `page` | integer | No | 1-based page of contributors. Request page + 1 while hasMore is true. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | GitHub repository URL, e.g. https://github.com/openai/whisper. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/github.repository_contributors","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","limit":"<integer>","page":"<integer>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### Facebook Ad Transcript

Get the spoken-word transcript of a Meta Ad Library video ad by ad ID or URL.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Facebook Ad Transcript pricing and uptime](https://getanyapi.com/api/facebook/ad-transcript) - live USD price, lane routing, and measured 30-day uptime. [Every Facebook endpoint](https://getanyapi.com/api/facebook).

`POST /v1/run/facebook.ad_transcript`

**Cost:** Up to $0.03488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.03488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/802d4b70-76e7-4916-bd3e-64e6ea4d22eb

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `id` | string | No | Meta Ad Library ad ID (e.g. "1020359190509080"). Provide either id or url. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | No | Meta Ad Library ad URL (e.g. "https://www.facebook.com/ads/library?id=1020359190509080"). Provide either id or url. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/facebook.ad_transcript","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","id":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### Facebook Ad Search

Search the Meta Ad Library by keyword and get matching ads (advertiser, creative text, CTA, platforms, and run dates) with cursor pagination.

**Price:** \$1.10 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 4 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Facebook Ad Search pricing and uptime](https://getanyapi.com/api/facebook/ads-search) - live USD price, lane routing, and measured 30-day uptime. [Every Facebook endpoint](https://getanyapi.com/api/facebook).

`POST /v1/run/facebook.ads_search`

**Cost:** Up to $0.01744 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.01744 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/92683532-aec6-4c22-88b3-58eee527b8e4

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `adType` | string | No | Restrict to all ads (default) or only political and issue ads. |
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `country` | string | No | Two-letter country code to scope results. Omit for all countries. |
| `cursor` | string | No | Opaque pagination cursor from a previous response's nextCursor. |
| `endDate` | string | No | Filter to ads with impressions on or before this date, in YYYY-MM-DD format. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `mediaType` | string | No | Creative media type filter. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Keyword to search the Meta Ad Library for (e.g. "protein powder"). |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `totalResults`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on an a |
| `searchType` | string | No | Match mode for the query: loose keyword match (keyword_unordered, the default) or exact phrase (keyword_exact_phrase). |
| `sortBy` | string | No | Sort order: impressions (highest first, the default) or recent (most recent). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `startDate` | string | No | Filter to ads with impressions on or after this date, in YYYY-MM-DD format. |
| `status` | string | No | Ad status filter. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/facebook.ads_search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"adType":"<string>","allowFallbacks":"<boolean>","country":"<string>","cursor":"<string>","endDate":"<string>","ignoreSources":"<string>","mediaType":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","requireFields":"<string>","searchType":"<string>","sortBy":"<string>","source":"<string>","startDate":"<string>","status":"<string>"}}'
```

### Facebook Comment Replies

List the replies to a Facebook post comment (text, author, reactions, and timestamps) as normalized JSON.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Facebook Comment Replies pricing and uptime](https://getanyapi.com/api/facebook/comment-replies) - live USD price, lane routing, and measured 30-day uptime. [Every Facebook endpoint](https://getanyapi.com/api/facebook).

`POST /v1/run/facebook.comment_replies`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/3349dbba-96df-4f25-ad82-73b626f4a7d8

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Pagination cursor from a previous response. |
| `expansionToken` | string | Yes | The expansion_token of the comment, from the post comments endpoint. |
| `feedbackId` | string | Yes | The feedback_id of the comment (not the comment id). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/facebook.comment_replies","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","expansionToken":"<string>","feedbackId":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### Facebook Company Ads

List the Meta Ad Library ads a company is running by page ID or company name (creative text, format, platforms, and run dates) with cursor pagination.

**Price:** \$1.10 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Facebook Company Ads pricing and uptime](https://getanyapi.com/api/facebook/company-ads) - live USD price, lane routing, and measured 30-day uptime. [Every Facebook endpoint](https://getanyapi.com/api/facebook).

`POST /v1/run/facebook.company_ads`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/83b11007-0a6f-48ef-99fb-7efb67a3708c

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `companyName` | string | No | Company name to search (e.g. "nike"). Exact-match and case-sensitive against the Meta Ad Library index; an advertiser with no indexed page returns found:false. |
| `country` | string | No | Two-letter country code to scope results. Defaults to all countries. |
| `cursor` | string | No | Opaque pagination cursor from a previous response's nextCursor. |
| `endDate` | string | No | Filter to ads with impressions on or before this date, in YYYY-MM-DD format. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `language` | string | No | Two-letter language code to filter ads (e.g. "EN", "ES", "FR"). |
| `mediaType` | string | No | Creative media type filter. |
| `pageId` | string | No | Company's Ad Library page ID. Provide either pageId or companyName. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `sortBy` | string | No | Sort order: impressions (highest first, the default) or recent (most recent). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `startDate` | string | No | Filter to ads with impressions on or after this date, in YYYY-MM-DD format. |
| `status` | string | No | Ad status filter. Defaults to ACTIVE. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/facebook.company_ads","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","companyName":"<string>","country":"<string>","cursor":"<string>","endDate":"<string>","ignoreSources":"<string>","language":"<string>","mediaType":"<string>","pageId":"<string>","preferLatencyUnderMs":"<integer>","sortBy":"<string>","source":"<string>","startDate":"<string>","status":"<string>"}}'
```

### Facebook Event Details

Fetch full details for a single Facebook event by ID or URL (name, schedule, venue, hosts, and attendance) as normalized JSON.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Facebook Event Details pricing and uptime](https://getanyapi.com/api/facebook/event-details) - live USD price, lane routing, and measured 30-day uptime. [Every Facebook endpoint](https://getanyapi.com/api/facebook).

`POST /v1/run/facebook.event_details`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/edd1bf39-4ff7-4de1-9aa9-27f5afd3d8db

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `id` | string | No | The event's numeric identifier. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | No | The event's Facebook URL. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/facebook.event_details","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","id":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### Facebook Events

List public Facebook events for a city or place by its events-page URL (event name, date, venue, and attendance) as normalized JSON.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Facebook Events pricing and uptime](https://getanyapi.com/api/facebook/events) - live USD price, lane routing, and measured 30-day uptime. [Every Facebook endpoint](https://getanyapi.com/api/facebook).

`POST /v1/run/facebook.events`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/f78d9ca8-4eda-4fd5-939f-df78477e43bb

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Pagination cursor from a previous response to fetch the next page. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `time` | string | No | Timeframe filter for the returned events. Defaults to all time. |
| `url` | string | Yes | URL of a city's or place's Facebook Events page (e.g. https://www.facebook.com/events/explore/saint-petersburg-florida/111326725552547). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/facebook.events","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","time":"<string>","url":"<string>"}}'
```

### Re-read a cached result for free

Re-read the full unshaped result of a prior run from its short-lived cache and re-shape it with the same `fields`, `max_items`, `summary`, and `jq` query params as /v1/run, all for FREE (no re-billing). Results are scoped to the customer that paid for them and cached for about 15 minutes. Use this to read the rest of, or reshape, a paid result instead of re-running and paying again.

`GET /v1/results/{id}`

**Cost:** Free. Calls cost nothing.

**Page:** https://www.orthogonal.com/api/anyapi/88551060-770d-4d4d-833c-9cb6cfe2b66e

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `id` | string | Yes | Path parameter — substitute directly into the endpoint `path`. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |

```bash
# Replace {id} in "path" with real values before sending
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/results/{id}","method":"GET","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>"}}'
```

### Ahrefs Backlinks

Get the referring pages linking to a domain or URL, each with the source page, anchor text, linking domain rating, and page title.

**Price:** billed per result - \$5.01 per 1,000 requests base + \$0.00 per 1,000 results, capped at \$5.01 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Ahrefs Backlinks pricing and uptime](https://getanyapi.com/api/ahrefs/backlinks) - live USD price, lane routing, and measured 30-day uptime. [Every Ahrefs endpoint](https://getanyapi.com/api/ahrefs).

`POST /v1/run/ahrefs.backlinks`

**Cost:** Up to $0.005461 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.005461 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/f0371d5c-db3a-41ca-aa69-2823c89458dc

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `mode` | string | No | Match scope: "exact" for the given URL only, or "subdomains" to include the domain and its subdomains. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | The domain or page URL to find backlinks for (e.g. "ahrefs.com"). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/ahrefs.backlinks","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","mode":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### Ahrefs Keyword Ideas

Get related keyword suggestions for any seed term, each with an Ahrefs difficulty and search-volume bucket.

**Price:** billed per result - \$0.06 per 1,000 requests base + \$4.95 per 1,000 results, capped at \$5.01 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Ahrefs Keyword Ideas pricing and uptime](https://getanyapi.com/api/ahrefs/keyword-ideas) - live USD price, lane routing, and measured 30-day uptime. [Every Ahrefs endpoint](https://getanyapi.com/api/ahrefs).

`POST /v1/run/ahrefs.keyword_ideas`

**Cost:** Up to $0.005461 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.005461 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/cf64ca6f-68a4-44c9-8cfb-a50e8cf3838f

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `country` | string | No | Two-letter country code that scopes the suggestions (e.g. us, gb, de). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `keyword` | string | Yes | The seed keyword to expand into related suggestions (e.g. "coffee"). |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/ahrefs.keyword_ideas","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","country":"<string>","ignoreSources":"<string>","keyword":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### Ahrefs Keyword Difficulty

Get the Ahrefs keyword-difficulty metrics for any search term: the difficulty score (0-100) and the number of referring domains a page needs to rank in the top 10 - as normalized JSON.

**Price:** billed per result - \$0.06 per 1,000 requests base + \$4.95 per 1,000 results, capped at \$5.01 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Ahrefs Keyword Difficulty pricing and uptime](https://getanyapi.com/api/ahrefs/keywords) - live USD price, lane routing, and measured 30-day uptime. [Every Ahrefs endpoint](https://getanyapi.com/api/ahrefs).

`POST /v1/run/ahrefs.keywords`

**Cost:** Up to $0.005461 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.005461 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/aebbedcb-43bf-4986-8498-89c8c37aef91

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `country` | string | No | Two-letter country code that scopes volume and difficulty (e.g. us, gb, de). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `keyword` | string | Yes | The search term to analyze (e.g. "seo tools"). |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/ahrefs.keywords","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","country":"<string>","ignoreSources":"<string>","keyword":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### Ahrefs Domain Overview

Get an SEO authority overview for any domain or URL: Domain Rating, total backlinks, and referring domains - as normalized JSON. For the keywords a domain ranks for, use seo.ranked_keywords.

**Price:** billed per result - \$0.06 per 1,000 requests base + \$4.95 per 1,000 results, capped at \$5.01 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Ahrefs Domain Overview pricing and uptime](https://getanyapi.com/api/ahrefs/overview) - live USD price, lane routing, and measured 30-day uptime. [Every Ahrefs endpoint](https://getanyapi.com/api/ahrefs).

`POST /v1/run/ahrefs.overview`

**Cost:** Up to $0.005461 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.005461 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/714a48cf-26e3-4e56-8df7-b7f20f292f54

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `mode` | string | No | Analysis scope: subdomains covers the whole domain, exact matches only the given URL. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | The domain or page URL to analyze (e.g. ahrefs.com). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/ahrefs.overview","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","mode":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### Ahrefs Traffic Overview

Get the Ahrefs organic traffic overview for any domain or URL: monthly traffic estimate and value, the top 5 keywords it already ranks for with position and traffic, top pages, traffic by country, and a monthly traffic history - as normalized JSON. For a domain's full ranked-keyword list with search volume and difficulty, use seo.ranked_keywords.

**Price:** billed per result - \$0.06 per 1,000 requests base + \$4.95 per 1,000 results, capped at \$5.01 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Ahrefs Traffic Overview pricing and uptime](https://getanyapi.com/api/ahrefs/traffic) - live USD price, lane routing, and measured 30-day uptime. [Every Ahrefs endpoint](https://getanyapi.com/api/ahrefs).

`POST /v1/run/ahrefs.traffic`

**Cost:** Up to $0.005461 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.005461 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/9d06f2ad-af75-4bd7-b6c3-37181ae74dd6

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `mode` | string | No | Analysis scope: subdomains covers the domain and its subdomains, domain covers the root domain only, prefix covers every page under the given path, exact matches only the given URL. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | The domain or page URL to analyze (e.g. ahrefs.com). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/ahrefs.traffic","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","mode":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### Airbnb Search

Search Airbnb listings by location and dates with optional price, beds/bedrooms/bathrooms, and guest-party filters and get results (name, total-stay price label, rating, host) as normalized JSON.

**Price:** billed per result - \$0.09 per 1,000 requests base + \$1.65 per 1,000 results, capped at \$33.10 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Airbnb Search pricing and uptime](https://getanyapi.com/api/airbnb/search) - live USD price, lane routing, and measured 30-day uptime. [Every Airbnb endpoint](https://getanyapi.com/api/airbnb).

`POST /v1/run/airbnb.search`

**Cost:** Up to $0.024089 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.024089 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/ba08d2de-e11d-450b-b22b-93a0628aae64

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `adults` | integer | No | Number of adult guests (e.g. 2). |
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `checkIn` | string | No | Check-in date in YYYY-MM-DD format (e.g. 2026-07-01). |
| `checkOut` | string | No | Check-out date in YYYY-MM-DD format (e.g. 2026-07-05). |
| `children` | integer | No | Number of child guests (e.g. 1). |
| `currency` | string | No | Currency code for prices (e.g. EUR). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `infants` | integer | No | Number of infant guests (e.g. 1). |
| `limit` | integer | No | Maximum number of results to return (1-20, default 20). You are billed per result returned, so a lower limit costs less. |
| `location` | string | Yes | Location to search listings in (e.g. London). |
| `minBathrooms` | integer | No | Minimum number of bathrooms (e.g. 2). |
| `minBedrooms` | integer | No | Minimum number of bedrooms (e.g. 2). |
| `minBeds` | integer | No | Minimum number of beds (e.g. 2). |
| `pets` | integer | No | Number of pets; only pet-friendly listings are returned when set (e.g. 1). |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `priceMax` | integer | No | Maximum search price in the selected currency (e.g. 300). |
| `priceMin` | integer | No | Minimum search price in the selected currency (e.g. 50). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/airbnb.search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"adults":"<integer>","allowFallbacks":"<boolean>","checkIn":"<string>","checkOut":"<string>","children":"<integer>","currency":"<string>","ignoreSources":"<string>","infants":"<integer>","limit":"<integer>","location":"<string>","minBathrooms":"<integer>","minBedrooms":"<integer>","minBeds":"<integer>","pets":"<integer>","preferLatencyUnderMs":"<integer>","priceMax":"<integer>","priceMin":"<integer>","source":"<string>"}}'
```

### Alibaba Search

Search Alibaba by keyword and get up to 25 wholesale listings (title, price range, minimum order, and supplier) in one normalized response.

**Price:** billed per result - \$0.88 per 1,000 results, capped at \$22.00 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Alibaba Search pricing and uptime](https://getanyapi.com/api/alibaba/search) - live USD price, lane routing, and measured 30-day uptime. [Every Alibaba endpoint](https://getanyapi.com/api/alibaba).

`POST /v1/run/alibaba.search`

**Cost:** Up to $0.021037 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.021037 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/296ee29a-2644-4b41-8987-6de2185f7071

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum number of results to return (1-25, default 25). You are billed per result returned, so a lower limit costs less. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Keywords to search for on Alibaba (e.g. "bluetooth speaker wholesale"). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/alibaba.search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","limit":"<integer>","preferLatencyUnderMs":"<integer>","query":"<string>","source":"<string>"}}'
```

### Facebook Events Search

Search public Facebook events by keyword and get structured event records (name, schedule, venue, pricing, and attendance) as normalized JSON.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Facebook Events Search pricing and uptime](https://getanyapi.com/api/facebook/events-search) - live USD price, lane routing, and measured 30-day uptime. [Every Facebook endpoint](https://getanyapi.com/api/facebook).

`POST /v1/run/facebook.events_search`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/10b42d3f-2d46-4321-a442-f2a8fd2bb79e

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Pagination cursor from a previous response. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | The query to search events for. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/facebook.events_search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","source":"<string>"}}'
```

### RedNote (Xiaohongshu) User Search

Search RedNote (Xiaohongshu) users by keyword and return normalized user records with pagination.

**Price:** \$12.00 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [RedNote (Xiaohongshu) User Search pricing and uptime](https://getanyapi.com/api/rednote/search-users) - live USD price, lane routing, and measured 30-day uptime. [Every Rednote endpoint](https://getanyapi.com/api/rednote).

`POST /v1/run/rednote.search_users`

**Cost:** Up to $0.01308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.01308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/8f9112b4-01a0-4890-9056-45ca5c437e02

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Pagination cursor from the previous response. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Keyword to search for on RedNote (Xiaohongshu). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/rednote.search_users","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","source":"<string>"}}'
```

### AliExpress Product

Look up one AliExpress product by id and get its price, original price, rating, reviews count, images, options, variants with stock, specifications, store, ship-from country and delivery estimate in one normalized response.

**Price:** \$0.90 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [AliExpress Product pricing and uptime](https://getanyapi.com/api/aliexpress/product) - live USD price, lane routing, and measured 30-day uptime. [Every Aliexpress endpoint](https://getanyapi.com/api/aliexpress).

`POST /v1/run/aliexpress.product`

**Cost:** Up to $0.002038 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.002038 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/8547b099-fceb-422a-8140-09252cc1d3d0

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `country` | string | No | Ship-to country as a 2-letter ISO code, e.g. US or DE. It changes prices, stock and the delivery estimate. |
| `currency` | string | No | Price currency as a 3-letter ISO code, e.g. USD or EUR. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `productId` | string | Yes | AliExpress product id, the number in the product URL (https://www.aliexpress.com/item/<id>.html), e.g. 3256807039224587. The AliExpress Search SKU returns it as productId. |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `video`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. Naming a combination that no single source retur |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/aliexpress.product","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","country":"<string>","currency":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","productId":"<string>","requireFields":"<string>","source":"<string>"}}'
```

### Amazon Products by ASIN

Look up to 10 Amazon products in one call by ASIN (title, brand, price, ratings, images, and attributes) as normalized JSON.

**Price:** billed per asin - \$3.85 per 1,000 asins, capped at \$38.50 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Amazon Products by ASIN pricing and uptime](https://getanyapi.com/api/amazon/asins) - live USD price, lane routing, and measured 30-day uptime. [Every Amazon endpoint](https://getanyapi.com/api/amazon).

`POST /v1/run/amazon.asins`

**Cost:** Up to $0.03597 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.03597 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/868cb150-58ca-4ce8-8026-b06f8013d675

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `amazonDomain` | string | No | Amazon marketplace domain to fetch products from (e.g. amazon.com, amazon.de, amazon.co.uk). |
| `asins` | string | Yes | Up to 10 Amazon ASINs to look up (e.g. ["B0CHX1W1XY", "B09G9FPHY6"]). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum number of results to return (1-10, default 10). You are billed per result returned, so a lower limit costs less. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/amazon.asins","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","amazonDomain":"<string>","asins":"<string>","ignoreSources":"<string>","limit":"<integer>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### Google Scholar

Search Google Scholar for academic papers with title, authors, citation count, and PDF link.

**Price:** \$0.85 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Google Scholar pricing and uptime](https://getanyapi.com/api/google/scholar) - live USD price, lane routing, and measured 30-day uptime. [Every Google endpoint](https://getanyapi.com/api/google).

`POST /v1/run/google.scholar`

**Cost:** Up to $0.001079 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001079 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/be95ac90-ca69-4fd8-9a82-c4c2f2872078

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | The Google Scholar search query. |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `year`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a record tha |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/google.scholar","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","requireFields":"<string>","source":"<string>"}}'
```

### Amazon Bestsellers

List the top-ranked products of any Amazon Best Sellers category (rank, title, price, and rating) in one normalized request.

**Price:** \$1.05 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Amazon Bestsellers pricing and uptime](https://getanyapi.com/api/amazon/bestsellers) - live USD price, lane routing, and measured 30-day uptime. [Every Amazon endpoint](https://getanyapi.com/api/amazon).

`POST /v1/run/amazon.bestsellers`

**Cost:** Up to $0.076736 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.076736 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/5b4b3af4-a81b-4c7b-bc6b-9816e87d9309

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum number of results to return (1-20, default 20). |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `offersCount` or `categoryName`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Amazon Best Sellers category URL (e.g. https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/amazon.bestsellers","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","limit":"<integer>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>","url":"<string>"}}'
```

### Amazon Product

Fetch full Amazon product details (title, brand, price when in stock, images, ratings, review count, variants, and attributes) from a product URL.

**Price:** \$0.90 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 4 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Amazon Product pricing and uptime](https://getanyapi.com/api/amazon/product) - live USD price, lane routing, and measured 30-day uptime. [Every Amazon endpoint](https://getanyapi.com/api/amazon).

`POST /v1/run/amazon.product`

**Cost:** Up to $0.007434 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.007434 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/9ed8f315-21e4-45f4-8c12-6812de9b34ce

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `category` or `condition`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be abs |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Full Amazon product URL (e.g. https://www.amazon.com/dp/B0CX23V2ZK). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/amazon.product","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>","url":"<string>"}}'
```

### Facebook Followers

List the public followers (or accounts followed) of any Facebook page or profile URL as normalized JSON records.

**Price:** billed per result - \$30.00 per 1,000 requests base + \$4.50 per 1,000 results, capped at \$120.00 per 1,000 requests.

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Facebook Followers pricing and uptime](https://getanyapi.com/api/facebook/followers) - live USD price, lane routing, and measured 30-day uptime. [Every Facebook endpoint](https://getanyapi.com/api/facebook).

`POST /v1/run/facebook.followers`

**Cost:** Up to $0.10791 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.10791 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/e120e0a8-4561-4e13-8e6a-c00efbb3f4a0

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `followType` | string | No | Which relation to fetch: 'follower' or 'following' (e.g. follower). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum number of results to return (1-20, default 20). You are billed per result returned, so a lower limit costs less. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Facebook page or profile URL to list follows for (e.g. https://www.facebook.com/nasa). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/facebook.followers","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","followType":"<string>","ignoreSources":"<string>","limit":"<integer>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### Facebook Group Posts

Fetch recent posts from any public Facebook group by URL: text, author, reactions, and comment counts.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Facebook Group Posts pricing and uptime](https://getanyapi.com/api/facebook/group-posts) - live USD price, lane routing, and measured 30-day uptime. [Every Facebook endpoint](https://getanyapi.com/api/facebook).

`POST /v1/run/facebook.group_posts`

**Cost:** Up to $0.005199 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.005199 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/ec2c430d-495d-4a96-85d3-42a67764fc7e

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Pagination cursor from a previous response to fetch the next page. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `sort` | string | No | Ordering for the returned posts (e.g. TOP_POSTS). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | The URL of a public Facebook group to fetch posts from (e.g. https://www.facebook.com/groups/instantpotcommunity/). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/facebook.group_posts","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","sort":"<string>","source":"<string>","url":"<string>"}}'
```

### Hacker News Story Comments

List the comments on a Hacker News story by id - text, author, and timestamp as clean JSON.

**Price:** \$1.50 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Hacker News Story Comments pricing and uptime](https://getanyapi.com/api/hackernews/story-comments) - live USD price, lane routing, and measured 30-day uptime. [Every Hackernews endpoint](https://getanyapi.com/api/hackernews).

`POST /v1/run/hackernews.story_comments`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/d360a08e-bd73-4857-b3fc-8d1d7498c9ae

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `id` | string | Yes | Hacker News story id, e.g. "47340079". |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/hackernews.story_comments","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","id":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### GitHub Repository Forks

List the forks of a GitHub repository by repository URL, with each fork's owner, description, stars, language and last push. Sort by newest, oldest or most starred.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [GitHub Repository Forks pricing and uptime](https://getanyapi.com/api/github/repository-forks) - live USD price, lane routing, and measured 30-day uptime. [Every Github endpoint](https://getanyapi.com/api/github).

`POST /v1/run/github.repository_forks`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/6db9add5-2721-45f3-8e18-9ff6f0a844bb

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Rows per page, 1-100 (GitHub's own page-size limit). Keep it the same while walking pages, because it sets the page size. |
| `page` | integer | No | 1-based page of forks. Request page + 1 while hasMore is true. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `sort` | string | No | Order of the forks. Defaults to newest. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | GitHub repository URL, e.g. https://github.com/openai/whisper. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/github.repository_forks","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","limit":"<integer>","page":"<integer>","preferLatencyUnderMs":"<integer>","sort":"<string>","source":"<string>","url":"<string>"}}'
```

### GitHub User Repositories

List a GitHub user's public repositories (name, description, language, stars, and forks) with sorting and cursor pagination.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [GitHub User Repositories pricing and uptime](https://getanyapi.com/api/github/user-repositories) - live USD price, lane routing, and measured 30-day uptime. [Every Github endpoint](https://getanyapi.com/api/github).

`POST /v1/run/github.user_repositories`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/d60f65aa-301e-49d8-bd62-7f5b27be3832

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Opaque pagination cursor from a previous response's nextCursor. Omit for the first page; pass it back to fetch the next page. |
| `direction` | string | No | Sort direction, ascending or descending, paired with sort. |
| `handle` | string | Yes | GitHub username. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `sort` | string | No | Repository ordering. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `type` | string | No | Which repositories to include: owner (default), all, or member. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/github.user_repositories","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","direction":"<string>","handle":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","sort":"<string>","source":"<string>","type":"<string>"}}'
```

### Facebook Marketplace

Search Facebook Marketplace listings by keyword near a location, filter by price, condition, delivery, recency, and availability, and get title, price, location, and image as normalized JSON.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Facebook Marketplace pricing and uptime](https://getanyapi.com/api/facebook/marketplace) - live USD price, lane routing, and measured 30-day uptime. [Every Facebook endpoint](https://getanyapi.com/api/facebook).

`POST /v1/run/facebook.marketplace`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/6c0fa7f0-2988-437a-a9b8-acfc573785af

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `availability` | string | No | Filter by availability: available (default), sold, or all (e.g. sold). |
| `condition` | string | No | Only return listings in this condition (e.g. used_good). |
| `cursor` | string | No | Pagination cursor from a previous response to fetch the next page. |
| `dateListed` | string | No | Only return listings posted within this window (e.g. last_7_days). |
| `deliveryMethod` | string | No | Only return listings offering this delivery method (e.g. shipping). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `lat` | string | Yes | Latitude of the search location (e.g. '30.2677'). |
| `lng` | string | Yes | Longitude of the search location (e.g. '-97.7475'). |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `priceMax` | integer | No | Maximum listing price in whole currency units, e.g. 500 for $500. Facebook may mix in a few suggested listings outside the range. |
| `priceMin` | integer | No | Minimum listing price in whole currency units, e.g. 100 for $100. Facebook may mix in a few suggested listings outside the range. |
| `query` | string | Yes | Search keyword for Marketplace listings (e.g. 'bike'). |
| `sort` | string | No | Sort order for the returned listings (e.g. price_ascend). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/facebook.marketplace","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","availability":"<string>","condition":"<string>","cursor":"<string>","dateListed":"<string>","deliveryMethod":"<string>","ignoreSources":"<string>","lat":"<string>","lng":"<string>","preferLatencyUnderMs":"<integer>","priceMax":"<integer>","priceMin":"<integer>","query":"<string>","sort":"<string>","source":"<string>"}}'
```

### Facebook Marketplace Item

Fetch full details for a single Facebook Marketplace listing by ID or URL (title, price, location, photos, and attributes) as normalized JSON.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Facebook Marketplace Item pricing and uptime](https://getanyapi.com/api/facebook/marketplace-item) - live USD price, lane routing, and measured 30-day uptime. [Every Facebook endpoint](https://getanyapi.com/api/facebook).

`POST /v1/run/facebook.marketplace_item`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/b07848d5-9df2-4553-94f2-20637e248fa9

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `id` | string | No | Facebook Marketplace item ID. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | No | Facebook Marketplace item URL. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/facebook.marketplace_item","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","id":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### Google Lens

Reverse image search: find web pages and visual matches for an image URL.

**Price:** \$0.85 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Google Lens pricing and uptime](https://getanyapi.com/api/google/lens) - live USD price, lane routing, and measured 30-day uptime. [Every Google endpoint](https://getanyapi.com/api/google).

`POST /v1/run/google.lens`

**Cost:** Up to $0.003237 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003237 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/ad377580-4ffe-4fa2-81a1-e8866aa12782

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Public URL of the image to search with. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/google.lens","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### Google Local Services

Find the businesses Google lists in Local Services ads for a service in a US city (plumbers, electricians, cleaners...): up to 20 per request, each with phone, star rating, review count, category, service area and Google profile link.

**Price:** \$0.85 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Google Local Services pricing and uptime](https://getanyapi.com/api/google/local-services) - live USD price, lane routing, and measured 30-day uptime. [Every Google endpoint](https://getanyapi.com/api/google).

`POST /v1/run/google.local_services`

**Cost:** Up to $0.0155 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.0155 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/40255805-d982-426d-b461-0f4a6d75424a

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum number of businesses to return (1-20, default 20). Google lists at most 20 businesses for one service in one city, so there are no further pages. |
| `location` | string | Yes | The US city to search, with its state (e.g. Denver, CO or Austin, TX). |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | The service to find businesses for, in everyday words (e.g. plumber, electrician, house cleaning, roofer). |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `yearsInBusiness` or `hours`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/google.local_services","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","limit":"<integer>","location":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","requireFields":"<string>","source":"<string>"}}'
```

### Google News

Search Google News by keyword and get fresh articles (headlines, sources, links, and publish times) as clean JSON.

**Price:** \$0.99 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Google News pricing and uptime](https://getanyapi.com/api/google/news) - live USD price, lane routing, and measured 30-day uptime. [Every Google endpoint](https://getanyapi.com/api/google).

`POST /v1/run/google.news`

**Cost:** Up to $0.001079 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001079 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/737ec1ec-dc57-400a-bc7c-82c24e866296

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `gl` | string | No | Two-letter country code for result localization (e.g. us, gb, de). |
| `hl` | string | No | Two-letter interface and results language code (e.g. en, es, de). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Requested article count (1-20, default 20). Google News returns its latest matching articles and may return more or fewer than requested. Price is flat per request. |
| `location` | string | No | Fine-grained location for result localization, given as a canonical Google location string (e.g. 'New York, United States', 'London, United Kingdom'). More specific than the country-level gl. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | News search query; supports operators like '-', 'OR', and 'site:' (e.g. bitcoin site:cnn.com). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `timeframe` | string | No | How far back to search, written as a count plus a unit: h hours, d days, w weeks, m months, y years. So 2h is the last two hours, 30d the last thirty days, 6m the last six months. Omit this field, or send 'all', to search without a time limit. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/google.news","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","gl":"<string>","hl":"<string>","ignoreSources":"<string>","limit":"<integer>","location":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","source":"<string>","timeframe":"<string>"}}'
```

### Google Patents

Search Google Patents with title, patent number, inventor, assignee, key dates, and PDF link.

**Price:** \$0.85 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Google Patents pricing and uptime](https://getanyapi.com/api/google/patents) - live USD price, lane routing, and measured 30-day uptime. [Every Google endpoint](https://getanyapi.com/api/google).

`POST /v1/run/google.patents`

**Cost:** Up to $0.001079 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001079 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/9bfd17cb-3149-457e-a113-ae550244bdae

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | The Google Patents search query. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/google.patents","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","source":"<string>"}}'
```

### Amazon Reviews

Pull customer reviews for any Amazon product by ASIN or URL: rating, title, text, date, and verified-purchase badge.

**Price:** \$1.30 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Amazon Reviews pricing and uptime](https://getanyapi.com/api/amazon/reviews) - live USD price, lane routing, and measured 30-day uptime. [Every Amazon endpoint](https://getanyapi.com/api/amazon).

`POST /v1/run/amazon.reviews`

**Cost:** Up to $0.24634 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.24634 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/9ad9b8ea-c9ba-479b-8317-b3f1d2303c55

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `endDate` | string | No | Only return reviews on or before this date, inclusive, in YYYY-MM-DD format (e.g. 2026-06-30). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `keyword` | string | No | Only return reviews whose title or text contains this keyword, case-insensitively (e.g. battery). |
| `limit` | integer | No | Maximum number of results to return (1-50, default 50). |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `product` | string | Yes | Amazon product ASIN (e.g. B07CMS5Q6P) or a product link on one of the marketplaces listed under region, such as https://www.amazon.co.uk/dp/<ASIN>, with the ASIN after /dp/, /gp/product/ or /product-reviews/. A link without an ASIN, such as a search results page (/s?k=...), or a link to another site or marketplace is refused as invalid input, with no charge. |
| `ratings` | string | No | Only return reviews whose star rating is in this set (e.g. ["5", "4"] for 4 and 5 star reviews); omit for all ratings. |
| `region` | string | No | Amazon marketplace domain the product ASIN belongs to (e.g. amazon.co.uk). |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `url`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a review that |
| `sort` | string | No | Review sort order: most helpful first or most recent first (e.g. recent). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `startDate` | string | No | Only return reviews on or after this date, inclusive, in YYYY-MM-DD format (e.g. 2026-01-01). |
| `verifiedOnly` | boolean | No | Set true to return only verified-purchase reviews (e.g. true). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/amazon.reviews","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","endDate":"<string>","ignoreSources":"<string>","keyword":"<string>","limit":"<integer>","preferLatencyUnderMs":"<integer>","product":"<string>","ratings":"<string>","region":"<string>","requireFields":"<string>","sort":"<string>","source":"<string>","startDate":"<string>","verifiedOnly":"<boolean>"}}'
```

### Amazon Search

Search Amazon from any search or category URL and get up to 20 matching products (title, price, rating, and thumbnail) in one normalized response.

**Price:** \$0.75 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Amazon Search pricing and uptime](https://getanyapi.com/api/amazon/search) - live USD price, lane routing, and measured 30-day uptime. [Every Amazon endpoint](https://getanyapi.com/api/amazon).

`POST /v1/run/amazon.search`

**Cost:** Up to $0.002289 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.002289 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/b5acf3ec-b447-48a4-8768-0203da22707e

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum number of results to return (1-20, default 20). |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Amazon search or category URL. For U.S. URLs, include page to select an Amazon results page; limit caps that page. Supported keyword, category, price, brand, rating and Prime selectors and standard Amazon sort orders are preserved. Unsupported selectors are rejected. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/amazon.search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","limit":"<integer>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### Amazon Seller Products

List one Amazon seller's storefront by seller ID, a page at a time, and get ASIN, title, price, list price, rating, reviews count, image, coupon and sponsored, Prime, best seller and Amazon's Choice flags for each product in one normalized response.

**Price:** \$0.85 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Amazon Seller Products pricing and uptime](https://getanyapi.com/api/amazon/seller-products) - live USD price, lane routing, and measured 30-day uptime. [Every Amazon endpoint](https://getanyapi.com/api/amazon).

`POST /v1/run/amazon.seller_products`

**Cost:** Up to $0.001166 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001166 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/3068b78e-1b9f-4f6f-8c06-804a7b097c94

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `page` | integer | No | 1-based page of the seller's storefront. Each page is billed as one request. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `region` | string | No | Amazon marketplace to read, as its domain (e.g. amazon.co.uk); omit it for amazon.com. |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `listPrice`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a produ |
| `sellerId` | string | Yes | Amazon seller ID, the value after seller= in a seller page URL (https://www.amazon.com/sp?seller=<id>), e.g. A11V4PRB7HXYNG. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/amazon.seller_products","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","page":"<integer>","preferLatencyUnderMs":"<integer>","region":"<string>","requireFields":"<string>","sellerId":"<string>","source":"<string>"}}'
```

### RedNote (Xiaohongshu) User Notes

List notes posted by a RedNote (Xiaohongshu) user and return normalized note records with pagination.

**Price:** \$12.00 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [RedNote (Xiaohongshu) User Notes pricing and uptime](https://getanyapi.com/api/rednote/user-notes) - live USD price, lane routing, and measured 30-day uptime. [Every Rednote endpoint](https://getanyapi.com/api/rednote).

`POST /v1/run/rednote.user_notes`

**Cost:** Up to $0.01308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.01308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/eb41c9af-605e-4fb4-8b1c-5b1f7d83983c

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Pagination cursor from the previous response. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `userId` | string | Yes | RedNote (Xiaohongshu) user ID. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/rednote.user_notes","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","userId":"<string>"}}'
```

### App Store App Details

Get an iOS app's App Store listing by app ID, in any storefront country: title, developer, rating, price, version, description, screenshots, and more.

**Price:** \$0.85 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [App Store App Details pricing and uptime](https://getanyapi.com/api/appstore/app) - live USD price, lane routing, and measured 30-day uptime. [Every Appstore endpoint](https://getanyapi.com/api/appstore).

`POST /v1/run/appstore.app`

**Cost:** Up to $0.000927 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.000927 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/cf525ee8-8f8a-4b25-ae0e-2b7c38631e49

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `appId` | string | Yes | Numeric App Store app ID, the digits at the end of the app's store URL without the 'id' prefix (e.g. 310633997). |
| `country` | string | No | Two-letter App Store storefront country code to read the listing from (e.g. gb); price and currency follow that storefront. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `ratingCount` or `screenshots`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/appstore.app","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","appId":"<string>","country":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>"}}'
```

### App Store Reviews

Get App Store reviews for any iOS app by app ID, in any storefront country: ratings, titles, and review text.

**Price:** \$0.90 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [App Store Reviews pricing and uptime](https://getanyapi.com/api/appstore/reviews) - live USD price, lane routing, and measured 30-day uptime. [Every Appstore endpoint](https://getanyapi.com/api/appstore).

`POST /v1/run/appstore.reviews`

**Cost:** Up to $0.01744 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.01744 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/98cd37c4-1c18-4b60-94b5-0f4f79bd1118

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `appId` | string | Yes | Numeric App Store app ID, the digits at the end of the app's store URL without the 'id' prefix (e.g. 310633997). |
| `country` | string | No | Two-letter App Store storefront country code to read reviews from. |
| `cursor` | string | No | Opaque pagination cursor from a previous response's nextCursor. Omit for the first page; pass it to fetch the next page of reviews. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum number of results to return (1-100, default 100). |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `helpfulVotes` or `version`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be a |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/appstore.reviews","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","appId":"<string>","country":"<string>","cursor":"<string>","ignoreSources":"<string>","limit":"<integer>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>"}}'
```

### App Store Search

Search the App Store for iOS apps by keyword, in any storefront country: app ID, title, developer, rating, ratings count, price, version, and more for each result.

**Price:** \$0.85 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [App Store Search pricing and uptime](https://getanyapi.com/api/appstore/search) - live USD price, lane routing, and measured 30-day uptime. [Every Appstore endpoint](https://getanyapi.com/api/appstore).

`POST /v1/run/appstore.search`

**Cost:** Up to $0.000927 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.000927 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/04ff33c0-7db6-4ec9-a2a5-2414ba848b07

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `country` | string | No | Two-letter App Store storefront country code to search (e.g. gb); results, prices, and currency follow that storefront. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum number of apps to return (1-50, default 20). |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Search keywords, as typed into the App Store search box (e.g. budget tracker). |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `sizeBytes` or `updatedUtc`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be a |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/appstore.search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","country":"<string>","ignoreSources":"<string>","limit":"<integer>","preferLatencyUnderMs":"<integer>","query":"<string>","requireFields":"<string>","source":"<string>"}}'
```

### ASOS Search

Search ASOS by keyword in any of its 11 country stores with optional sort, price-range, and page filters and get title, price, brand, and colour for each product in one normalized response.

**Price:** \$0.85 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [ASOS Search pricing and uptime](https://getanyapi.com/api/asos/search) - live USD price, lane routing, and measured 30-day uptime. [Every Asos endpoint](https://getanyapi.com/api/asos).

`POST /v1/run/asos.search`

**Cost:** Up to $0.001166 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001166 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/d033e697-2c8a-47c2-b31a-9d78fb46adb6

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `country` | string | No | ASOS country store to search, which also sets the price currency (gb GBP, us USD, au AUD, de/fr/it/es/nl EUR, se SEK, dk DKK, pl PLN); defaults to gb, the UK store. Product ids and URLs are store-specific. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `maxPrice` | number | No | Optional maximum product price, in the store's currency. |
| `minPrice` | number | No | Optional minimum product price, in the store's currency. |
| `page` | integer | No | 1-based results page of 48 products. Each page is billed as one request. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Search keywords, e.g. "white sneakers" or "summer dress". |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `inStock`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. Naming a combination that no single source ret |
| `sort` | string | No | Result sort order; omit for ASOS's recommended order (e.g. new for newest arrivals first). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/asos.search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","country":"<string>","ignoreSources":"<string>","maxPrice":"<number>","minPrice":"<number>","page":"<integer>","preferLatencyUnderMs":"<integer>","query":"<string>","requireFields":"<string>","sort":"<string>","source":"<string>"}}'
```

### Best Buy Reviews

Pull a page of 10 customer reviews for any BestBuy.com product by URL, newest first or by relevance, helpfulness, or rating: rating, title, text, date, reviewer, and verified-purchase badge.

**Price:** \$0.85 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Best Buy Reviews pricing and uptime](https://getanyapi.com/api/bestbuy/reviews) - live USD price, lane routing, and measured 30-day uptime. [Every Bestbuy endpoint](https://getanyapi.com/api/bestbuy).

`POST /v1/run/bestbuy.reviews`

**Cost:** Up to $0.001166 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001166 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/d89d6216-3711-4b5b-aa6d-32807fee4bf6

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `page` | integer | No | 1-based page of 10 reviews; Best Buy serves at most 1000 pages. Each page is billed as one request; keep url and sort the same while walking pages. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `rating`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. Naming a combination that no single source retu |
| `sort` | string | No | Review order: recent (newest first, the default), oldest, relevancy, helpful, rating_high, or rating_low (e.g. helpful). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Best Buy product page URL that carries the numeric Best Buy SKU, either the .../sku/6376564 form the Best Buy Search SKU returns or the older .../6376564.p?skuId=6376564 form. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/bestbuy.reviews","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","page":"<integer>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","sort":"<string>","source":"<string>","url":"<string>"}}'
```

### Microsoft Copilot Search

Ask Microsoft Copilot (the AI answer in Bing) a question and get its web-grounded answer with the sources it cites as clean JSON - for tracking how Copilot answers and which sites it cites.

**Price:** \$0.85 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Microsoft Copilot Search pricing and uptime](https://getanyapi.com/api/bing/copilot) - live USD price, lane routing, and measured 30-day uptime. [Every Bing endpoint](https://getanyapi.com/api/bing).

`POST /v1/run/bing.copilot`

**Cost:** Up to $0.00702 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.00702 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/b02ace28-f564-4f09-ab44-72a698fbb641

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `prompt` | string | Yes | The question or prompt for Microsoft Copilot to answer using Bing web search. |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `answerMarkdown`, `inlineCitations` or `tables`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/bing.copilot","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","prompt":"<string>","requireFields":"<string>","source":"<string>"}}'
```

### Bluesky Post

Get a single Bluesky post by URL - text, author handle, like, reply, and repost counts as clean JSON.

**Price:** \$1.10 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Bluesky Post pricing and uptime](https://getanyapi.com/api/bluesky/post) - live USD price, lane routing, and measured 30-day uptime. [Every Bluesky endpoint](https://getanyapi.com/api/bluesky).

`POST /v1/run/bluesky.post`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/6b646f4a-b1ce-4d11-8703-caab491f2cd9

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Bluesky post URL, e.g. "https://bsky.app/profile/bsky.app/post/3l6oveex3ii2l". |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/bluesky.post","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### Bluesky Profile

Get a Bluesky user's public profile by handle - display name, bio, follower and post counts as clean JSON.

**Price:** \$1.10 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Bluesky Profile pricing and uptime](https://getanyapi.com/api/bluesky/profile) - live USD price, lane routing, and measured 30-day uptime. [Every Bluesky endpoint](https://getanyapi.com/api/bluesky).

`POST /v1/run/bluesky.profile`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/dbea834e-2602-43cb-b3e8-2839cf0254c7

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `handle` | string | Yes | Bluesky handle, e.g. "bsky.app" or "jay.bsky.team". |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/bluesky.profile","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","handle":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### Bluesky User Posts

List a Bluesky account's recent posts (text, author handle, like, reply, and repost counts) by handle as clean JSON.

**Price:** \$1.10 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Bluesky User Posts pricing and uptime](https://getanyapi.com/api/bluesky/user-posts) - live USD price, lane routing, and measured 30-day uptime. [Every Bluesky endpoint](https://getanyapi.com/api/bluesky).

`POST /v1/run/bluesky.user_posts`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/4d19f0bb-d7cf-4c20-9157-c4864893aa94

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `handle` | string | Yes | Bluesky handle, e.g. "bsky.app" or "jay.bsky.team". |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/bluesky.user_posts","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","handle":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### Facebook Marketplace Location Search

Resolve a place name to Facebook Marketplace locations with coordinates and metadata as normalized JSON.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Facebook Marketplace Location Search pricing and uptime](https://getanyapi.com/api/facebook/marketplace-location-search) - live USD price, lane routing, and measured 30-day uptime. [Every Facebook endpoint](https://getanyapi.com/api/facebook).

`POST /v1/run/facebook.marketplace_location_search`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/380e7ec0-488b-4770-b82f-c7337e19e4da

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Location search query (e.g. a city name). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/facebook.marketplace_location_search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","source":"<string>"}}'
```

### Facebook Page Contact Info

Look up a Facebook Page's public contact details (email, phone, website, and address) by page URL or ID.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Facebook Page Contact Info pricing and uptime](https://getanyapi.com/api/facebook/page-contact) - live USD price, lane routing, and measured 30-day uptime. [Every Facebook endpoint](https://getanyapi.com/api/facebook).

`POST /v1/run/facebook.page_contact`

**Cost:** Up to $0.01199 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.01199 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/232a25ee-eb43-4224-97ed-8f6841815e9b

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `language` | string | No | Locale code for the returned data (e.g. en-US). |
| `page` | string | Yes | Facebook Page URL or page ID to look up (e.g. https://www.facebook.com/nasa). A link to a post, video, photo or reels tab on a page is read as that page. A link to Facebook's own business, about, marketplace, fb-answers, videos, photos or reels section, a pages link without the page's id, or profile.php without its id= names no page and is refused as invalid input, with no charge. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `createdUtc` or `adStatus`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be ab |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/facebook.page_contact","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","language":"<string>","page":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>"}}'
```

### GitHub Repository Issues

List a GitHub repository's issues and pull requests by repository URL (GitHub lists pull requests as issues), with each one's author, state, labels, counts and body. Filter by state, sort and update date.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [GitHub Repository Issues pricing and uptime](https://getanyapi.com/api/github/repository-issues) - live USD price, lane routing, and measured 30-day uptime. [Every Github endpoint](https://getanyapi.com/api/github).

`POST /v1/run/github.repository_issues`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/91fa69b1-3db9-4b31-a798-ea5738cd7dbe

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Rows per page, 1-100 (GitHub's own page-size limit). Keep it the same while walking pages, because it sets the page size. |
| `order` | string | No | Sort direction. Defaults to desc. |
| `page` | integer | No | 1-based page of issues. Request page + 1 while hasMore is true. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `since` | string | No | Only issues updated on or after this date (YYYY-MM-DD). |
| `sort` | string | No | Sort by creation date, last update, or number of comments. Defaults to created. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `state` | string | No | Which issues to list. Defaults to open. |
| `url` | string | Yes | GitHub repository URL, e.g. https://github.com/openai/whisper. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/github.repository_issues","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","limit":"<integer>","order":"<string>","page":"<integer>","preferLatencyUnderMs":"<integer>","since":"<string>","sort":"<string>","source":"<string>","state":"<string>","url":"<string>"}}'
```

### GitHub User Activity

List a GitHub user's public contribution activity by handle (grouped monthly summaries of commits, pull requests, and issues with repository links) for a given year.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [GitHub User Activity pricing and uptime](https://getanyapi.com/api/github/user-activity) - live USD price, lane routing, and measured 30-day uptime. [Every Github endpoint](https://getanyapi.com/api/github).

`POST /v1/run/github.user_activity`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/dd353336-f389-4a30-9663-42af0f835451

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Pagination cursor from a previous response (pages backward by month). |
| `handle` | string | Yes | GitHub username. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `year` | string | No | Year of contribution activity to return (defaults to the current year). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/github.user_activity","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","handle":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","year":"<string>"}}'
```

### Facebook Page Lookup

Look up Facebook Pages and profiles by name with Facebook's own quick search. A name lookup that returns basic identity fields only: name, URL, profile image, Facebook id, and verified status. Matches can include personal profiles as well as Pages. For full Page details (category, followers, phone, website), use facebook.search_pages.

**Price:** \$9.75 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Facebook Page Lookup pricing and uptime](https://getanyapi.com/api/facebook/page-lookup) - live USD price, lane routing, and measured 30-day uptime. [Every Facebook endpoint](https://getanyapi.com/api/facebook).

`POST /v1/run/facebook.page_lookup`

**Cost:** Up to $0.045944 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.045944 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/919d886c-c52e-4e21-bb80-089768a53040

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum number of matches to return (1-7, default 7). Facebook's quick search answers a name with at most 7 matches. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Name to look up, as you would type it into Facebook's search box (e.g. NASA or plumber chicago). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/facebook.page_lookup","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","limit":"<integer>","preferLatencyUnderMs":"<integer>","query":"<string>","source":"<string>"}}'
```

### Facebook Page Photos

Fetch recent photos posted by any public Facebook page or profile (image URLs, captions, and dimensions) as normalized JSON.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Facebook Page Photos pricing and uptime](https://getanyapi.com/api/facebook/photos) - live USD price, lane routing, and measured 30-day uptime. [Every Facebook endpoint](https://getanyapi.com/api/facebook).

`POST /v1/run/facebook.photos`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/13cbab4b-f72a-472c-8d51-d85a78bf9d75

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Pagination cursor from a previous response to fetch the next page. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `imageWidth`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a phot |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | URL of the public Facebook page or profile to fetch photos from (e.g. https://www.facebook.com/Spurs). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/facebook.photos","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>","url":"<string>"}}'
```

### Facebook Post

Fetch a single Facebook post by URL with its text and engagement counts (likes, comments, shares, views).

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Facebook Post pricing and uptime](https://getanyapi.com/api/facebook/post) - live USD price, lane routing, and measured 30-day uptime. [Every Facebook endpoint](https://getanyapi.com/api/facebook).

`POST /v1/run/facebook.post`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/3d74148d-96ef-499f-900f-bc93f35733bc

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `videoId` or `views`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent o |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Full Facebook post URL. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/facebook.post","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>","url":"<string>"}}'
```

### GitHub User Contributions

Fetch a GitHub user's contribution graph for a year (total contributions plus per-day counts and heatmap intensity).

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [GitHub User Contributions pricing and uptime](https://getanyapi.com/api/github/user-contributions) - live USD price, lane routing, and measured 30-day uptime. [Every Github endpoint](https://getanyapi.com/api/github).

`POST /v1/run/github.user_contributions`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/cc7faf5b-7c65-4331-a21b-bcb654088f03

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `handle` | string | Yes | GitHub username. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `year` | integer | No | Calendar year of the contribution graph. Defaults to the current year. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/github.user_contributions","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","handle":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","year":"<integer>"}}'
```

### Facebook Post Comments

List the comments on a Facebook post by URL with cursor pagination (text, author, reactions, reply count).

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Facebook Post Comments pricing and uptime](https://getanyapi.com/api/facebook/post-comments) - live USD price, lane routing, and measured 30-day uptime. [Every Facebook endpoint](https://getanyapi.com/api/facebook).

`POST /v1/run/facebook.post_comments`

**Cost:** Up to $0.005199 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.005199 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/88203d12-20c7-487a-90d1-ee6920bd9016

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Pagination cursor from a previous response's nextCursor. |
| `feedbackId` | string | No | Facebook feedback id for the post (alternative to url). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `feedbackId` or `hasNextPage`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | No | Full Facebook post URL. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/facebook.post_comments","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","feedbackId":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>","url":"<string>"}}'
```

### Booking.com Search

Search Booking.com stays by destination and dates with optional guest and room occupancy and get hotel results (name, price, review score, location) as normalized JSON.

**Price:** billed per result - \$2.20 per 1,000 requests base + \$4.95 per 1,000 results, capped at \$102.00 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Booking.com Search pricing and uptime](https://getanyapi.com/api/booking/search) - live USD price, lane routing, and measured 30-day uptime. [Every Booking endpoint](https://getanyapi.com/api/booking).

`POST /v1/run/booking.search`

**Cost:** Up to $0.11118 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.11118 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/563f2cbd-5d7b-42f4-87aa-bfadd5b652f3

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `adults` | integer | No | Number of adult guests (e.g. 2). |
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `checkIn` | string | No | Check-in date in YYYY-MM-DD format (e.g. 2026-07-01). Defaults to tomorrow. |
| `checkOut` | string | No | Check-out date in YYYY-MM-DD format (e.g. 2026-07-05). Defaults to the day after check-in. |
| `children` | integer | No | Number of child guests (e.g. 1). |
| `currency` | string | No | Currency code for prices (e.g. EUR). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum number of hotels to return (1-20, default 20). You are billed per result returned, so a lower limit costs less. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Destination city to search for stays in (e.g. Paris). |
| `rooms` | integer | No | Number of rooms to book (e.g. 1). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/booking.search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"adults":"<integer>","allowFallbacks":"<boolean>","checkIn":"<string>","checkOut":"<string>","children":"<integer>","currency":"<string>","ignoreSources":"<string>","limit":"<integer>","preferLatencyUnderMs":"<integer>","query":"<string>","rooms":"<integer>","source":"<string>"}}'
```

### Facebook Profile Reels

List a Facebook page's reels by URL with cursor pagination (caption, view count, permalink, thumbnail).

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Facebook Profile Reels pricing and uptime](https://getanyapi.com/api/facebook/profile-reels) - live USD price, lane routing, and measured 30-day uptime. [Every Facebook endpoint](https://getanyapi.com/api/facebook).

`POST /v1/run/facebook.profile_reels`

**Cost:** Up to $0.005199 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.005199 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/bfa91d53-0604-48b6-9670-0124ce9916d9

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Pagination cursor from a previous response. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `feedbackId` or `authorVerified`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Full Facebook page/profile URL. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/facebook.profile_reels","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>","url":"<string>"}}'
```

### Brave Search

Run a Brave web search and get the ranked organic results (title, URL, snippet, position, display URL, domain) as clean JSON. Brave answers from its own independent index. Returns up to 20 results per call, with related searches and video results where the source has them; page deeper with page and pick the country Brave searches from.

**Price:** \$0.85 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Brave Search pricing and uptime](https://getanyapi.com/api/brave/search) - live USD price, lane routing, and measured 30-day uptime. [Every Brave endpoint](https://getanyapi.com/api/brave).

`POST /v1/run/brave.search`

**Cost:** Up to $0.000927 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.000927 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/50b2af6f-f75a-4937-a8ba-c7aab12b14fe

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `country` | string | No | ISO-3166 alpha-2 country Brave searches from, e.g. US, GB, DE. Brave ranks and localizes results for that country. Only the countries Brave offers are accepted; US is served by every source and the others by the sources that can target them. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum number of organic results to return (1-20, default 20). Brave serves about 20 organic results per page, and some queries carry fewer. |
| `page` | integer | No | Which page of Brave results to return, starting at 1 (up to 10); a page holds about 20 results. Each page is billed as one request. Pages after the first are served only for country US, by the one source that continues each page exactly where the last ended. A limit below the page size drops the rest of that page, so keep the default limit to walk every result. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | The Brave search query. |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `relatedSearches` or `publishedUtc`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can st |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/brave.search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","country":"<string>","ignoreSources":"<string>","limit":"<integer>","page":"<integer>","preferLatencyUnderMs":"<integer>","query":"<string>","requireFields":"<string>","source":"<string>"}}'
```

### SEO Domain Rank Overview

Get AnyAPI SEO domain ranking, organic traffic, and paid traffic metrics as normalized JSON.

**Price:** billed per result - \$14.55 per 1,000 requests base + \$0.00 per 1,000 results, capped at \$14.55 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [SEO Domain Rank Overview pricing and uptime](https://getanyapi.com/api/seo/domain-rank-overview) - live USD price, lane routing, and measured 30-day uptime. [Every Seo endpoint](https://getanyapi.com/api/seo).

`POST /v1/run/seo.domain_rank_overview`

**Cost:** Up to $0.01586 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.01586 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/5feecb92-abdc-4020-b5af-8eb6cd0e034a

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `language` | string | No | Language code for SEO domain metrics. |
| `location` | integer | No | Location code for SEO domain metrics. The default is the United States. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `target` | string | Yes | Domain to analyze, without a protocol or leading www. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/seo.domain_rank_overview","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","language":"<string>","location":"<integer>","preferLatencyUnderMs":"<integer>","source":"<string>","target":"<string>"}}'
```

### GitHub User Followers

List a GitHub user's followers by handle (each follower's login, type, avatar, and profile URL) with pagination.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [GitHub User Followers pricing and uptime](https://getanyapi.com/api/github/user-followers) - live USD price, lane routing, and measured 30-day uptime. [Every Github endpoint](https://getanyapi.com/api/github).

`POST /v1/run/github.user_followers`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/74b31a4d-c4d7-4e26-8da7-045d3880b79e

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Pagination cursor from a previous response (page number, defaults to 1). |
| `handle` | string | Yes | GitHub username. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/github.user_followers","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","handle":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### Facebook Company Search

Search the Meta Ad Library for advertisers by keyword and get matching pages: page ID, category, verification, follower counts, and linked Instagram.

**Price:** \$1.10 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Facebook Company Search pricing and uptime](https://getanyapi.com/api/facebook/search-companies) - live USD price, lane routing, and measured 30-day uptime. [Every Facebook endpoint](https://getanyapi.com/api/facebook).

`POST /v1/run/facebook.search_companies`

**Cost:** Up to $0.00436 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.00436 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/d2a54bf8-24fc-4f6b-9ab8-759610ec89ca

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Keyword to search advertiser pages for (e.g. "nike"). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/facebook.search_companies","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","source":"<string>"}}'
```

### Facebook Page Search

Search Facebook Pages by keyword, optionally narrowed to a location, and get structured page profiles (name, category, followers, contact details).

**Price:** billed per result - \$1.10 per 1,000 requests base + \$12.10 per 1,000 results, capped at \$123.00 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Facebook Page Search pricing and uptime](https://getanyapi.com/api/facebook/search-pages) - live USD price, lane routing, and measured 30-day uptime. [Every Facebook endpoint](https://getanyapi.com/api/facebook).

`POST /v1/run/facebook.search_pages`

**Cost:** Up to $0.11009 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.11009 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/cafd5355-e821-440f-a685-0a58e3c19a33

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum number of results to return (1-10, default 10). You are billed per result returned, so a lower limit costs less. |
| `location` | string | No | Optional free-text location to narrow the search: a city, province, or country (e.g. 'Berlin'). |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Keyword to search Facebook Pages for (e.g. 'coffee roasters'). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/facebook.search_pages","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","limit":"<integer>","location":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","source":"<string>"}}'
```

### Facebook Post Search

Search public Facebook posts by keyword, optionally filtered by location, and get structured post records (text, author, engagement).

**Price:** \$30.00 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Facebook Post Search pricing and uptime](https://getanyapi.com/api/facebook/search-posts) - live USD price, lane routing, and measured 30-day uptime. [Every Facebook endpoint](https://getanyapi.com/api/facebook).

`POST /v1/run/facebook.search_posts`

**Cost:** Up to $0.070741 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.070741 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/0ec36594-07ef-49fd-a626-53f950ed3ddc

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `endDate` | string | No | Only return posts published on or before this date, format YYYY-MM-DD (e.g. 2024-12-31). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum number of results to return (1-20, default 20). |
| `location` | string | No | Optional place name; include both city and country for best matches (e.g. 'Paris, France'). Uses Facebook's place filter, which favors posts tagged at that place rather than every post by people who live there, and can still return some posts from elsewhere. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Keyword or phrase to search Facebook posts for (e.g. 'product launch'). |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `imagesCount` or `albumPreview`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `startDate` | string | No | Only return posts published on or after this date, format YYYY-MM-DD (e.g. 2024-01-01). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/facebook.search_posts","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","endDate":"<string>","ignoreSources":"<string>","limit":"<integer>","location":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","requireFields":"<string>","source":"<string>","startDate":"<string>"}}'
```

### Capterra Reviews

Pull Capterra software reviews for any product: overall and sub-ratings, pros and cons, reviewer job title, company size, and industry as clean JSON.

**Price:** billed per result - \$5.50 per 1,000 requests base + \$0.88 per 1,000 results, capped at \$93.50 per 1,000 requests.

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Capterra Reviews pricing and uptime](https://getanyapi.com/api/capterra/reviews) - live USD price, lane routing, and measured 30-day uptime. [Every Capterra endpoint](https://getanyapi.com/api/capterra).

`POST /v1/run/capterra.reviews`

**Cost:** Up to $0.172656 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.172656 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/a465ab86-28f7-43ba-873a-685d65e0c961

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum number of reviews to return. The minimum is 10 because the cheapest Capterra review source will not serve a smaller page. You are billed per returned result, so a lower limit costs less. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `product` | string | Yes | Capterra product URL, for example https://www.capterra.com/p/135003/Slack/. Capterra identifies a product by both its numeric id and its slug, so the full URL is required. |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `ownerResponse`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a r |
| `sortBy` | string | No | Sort order for the returned reviews: newest first, most complete first, or highest or lowest rated first. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/capterra.reviews","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","limit":"<integer>","preferLatencyUnderMs":"<integer>","product":"<string>","requireFields":"<string>","sortBy":"<string>","source":"<string>"}}'
```

### Fiverr Gig Search

Extract Fiverr gig listings from any search or category URL: titles, sellers, ratings, and pricing as structured JSON.

**Price:** billed per result - \$1.65 per 1,000 results, capped at \$33.00 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Fiverr Gig Search pricing and uptime](https://getanyapi.com/api/fiverr/search) - live USD price, lane routing, and measured 30-day uptime. [Every Fiverr endpoint](https://getanyapi.com/api/fiverr).

`POST /v1/run/fiverr.search`

**Cost:** Up to $0.03597 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.03597 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/f370cdea-106d-4917-b98c-9919c320d615

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum number of results to return (1-20, default 20). You are billed per result returned, so a lower limit costs less. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Fiverr search or category page URL to extract gigs from. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/fiverr.search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","limit":"<integer>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### G2 Reviews

Pull G2 software reviews for any product: star rating, what reviewers like and dislike, problems solved, market segment, and G2's rating rubric as clean JSON.

**Price:** billed per result - \$0.06 per 1,000 requests base + \$0.05 per 1,000 results, capped at \$4.46 per 1,000 requests.

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [G2 Reviews pricing and uptime](https://getanyapi.com/api/g2/reviews) - live USD price, lane routing, and measured 30-day uptime. [Every G2 endpoint](https://getanyapi.com/api/g2).

`POST /v1/run/g2.reviews`

**Cost:** Up to $0.125895 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.125895 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/09b1011f-4c7d-446f-9cdc-00ecf6b0b8f2

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum number of reviews to return. The minimum is 50 because G2 review sources will not serve a smaller page. You are billed per returned result, so a lower limit costs less. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `product` | string | Yes | G2 product slug, for example hubspot-marketing-hub. A full G2 product URL is also accepted and reduced to its slug. |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `productSlug`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a rev |
| `sortBy` | string | No | Sort order for the returned reviews: newest first, most helpful first, highest or lowest rated first, or G2's own default ordering. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/g2.reviews","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","limit":"<integer>","preferLatencyUnderMs":"<integer>","product":"<string>","requireFields":"<string>","sortBy":"<string>","source":"<string>"}}'
```

### ChatGPT Search

Ask ChatGPT a web-grounded question and receive an answer with source citations. ChatGPT composes each answer per request, so the same prompt returns different wording and a different source set.

**Price:** \$1.80 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [ChatGPT Search pricing and uptime](https://getanyapi.com/api/chatgpt/search) - live USD price, lane routing, and measured 30-day uptime. [Every Chatgpt endpoint](https://getanyapi.com/api/chatgpt).

`POST /v1/run/chatgpt.search`

**Cost:** Up to $0.005232 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.005232 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/cdc3b732-6378-4295-820d-a8499179c5d2

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `country` | string | No | ISO-3166 alpha-2 country to ask from, e.g. US, GB, DE. ChatGPT localizes both the pages it retrieves and the answer it writes, so this is the difference between what a US buyer and a UK buyer are told. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `prompt` | string | Yes | Question or research prompt for ChatGPT to answer using web search. |
| `requireAds` | boolean | No | Serve only from a source that can return sponsored placements shown with the answer. One source currently qualifies, so the request cannot fall back when it is unavailable. |
| `requireEntities` | boolean | No | Serve only from a source that can return brands and other named entities recognized in the answer. One source currently qualifies, so the request cannot fall back when it is unavailable. |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `cited` or `ads`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a |
| `requirePlaces` | boolean | No | Serve only from a source that can return places shown with the answer. Leaving this off still returns places whenever the source that answered can. Turning it on selects the single source that guarantees them, which costs more and has nothing to fall back to if it is unavailable. |
| `requireShoppingCards` | boolean | No | Serve only from a source that can return shopping cards shown with the answer. Leaving this off still returns shopping cards whenever the source that answered can. Turning it on selects the single source that guarantees them, which costs more and has nothing to fall back to if it is unavailable. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `webSearch` | string | No | Whether to insist ChatGPT browses the web. force instructs it to search and is the default; auto lets ChatGPT decide, which is cheaper and answers from memory roughly half the time. Check webSearchTriggered for what actually happened - an answer written without a search is not web-grounded. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/chatgpt.search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","country":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","prompt":"<string>","requireAds":"<boolean>","requireEntities":"<boolean>","requireFields":"<string>","requirePlaces":"<boolean>","requireShoppingCards":"<boolean>","source":"<string>","webSearch":"<string>"}}'
```

### CoinMarketCap Listings

Get the current top cryptocurrencies from CoinMarketCap (rank, price, market cap, volume, and 24h change) as normalized JSON.

**Price:** billed per result - \$1.98 per 1,000 results, capped at \$49.50 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [CoinMarketCap Listings pricing and uptime](https://getanyapi.com/api/coinmarketcap/listings) - live USD price, lane routing, and measured 30-day uptime. [Every Coinmarketcap endpoint](https://getanyapi.com/api/coinmarketcap).

`POST /v1/run/coinmarketcap.listings`

**Cost:** Up to $0.053955 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.053955 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/57f37b8c-aedc-4af2-a934-42e1a07b550f

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum number of results to return (1-25, default 25). You are billed per result returned, so a lower limit costs less. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/coinmarketcap.listings","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","limit":"<integer>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### Congress Stock Trades

Get US Congress members' financial disclosures and stock trades (member, ticker, transaction type, amount range, and dates), filterable by member, ticker, or date range. Results come newest filing first (by reportedUtc, not tradedUtc), so a recent filing can list trades made years earlier.

**Price:** billed per result - \$1.10 per 1,000 requests base + \$2.09 per 1,000 results, capped at \$53.40 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Congress Stock Trades pricing and uptime](https://getanyapi.com/api/congress/trades) - live USD price, lane routing, and measured 30-day uptime. [Every Congress endpoint](https://getanyapi.com/api/congress).

`POST /v1/run/congress.trades`

**Cost:** Up to $0.050358 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.050358 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/159ce704-b702-49a3-ac5e-e9754dd58ec2

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `endDate` | string | No | Latest transaction date to include, inclusive, in YYYY-MM-DD format (e.g. 2026-06-01). |
| `firstName` | string | No | Filter by the congressional member's first name, case-insensitive partial match (e.g. Nancy). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `lastName` | string | No | Filter by the congressional member's last name, case-insensitive partial match (e.g. Pelosi). |
| `limit` | integer | No | Maximum number of results to return (1-25, default 25). You are billed per result returned, so a lower limit costs less. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `startDate` | string | No | Earliest transaction date to include, inclusive, in YYYY-MM-DD format (e.g. 2026-01-01). |
| `ticker` | string | No | Filter to transactions involving this stock ticker symbol (e.g. NVDA). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/congress.trades","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","endDate":"<string>","firstName":"<string>","ignoreSources":"<string>","lastName":"<string>","limit":"<integer>","preferLatencyUnderMs":"<integer>","source":"<string>","startDate":"<string>","ticker":"<string>"}}'
```

### Douyin Profile

Look up a public Douyin profile by sec_user_id and return normalized profile statistics.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Douyin Profile pricing and uptime](https://getanyapi.com/api/douyin/profile) - live USD price, lane routing, and measured 30-day uptime. [Every Douyin endpoint](https://getanyapi.com/api/douyin).

`POST /v1/run/douyin.profile`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/a61df189-9231-45b3-bc8b-ee171ddc32d7

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `secUserId` | string | Yes | Douyin sec_user_id for the public account. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/douyin.profile","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","secUserId":"<string>","source":"<string>"}}'
```

### Douyin Video Search

Search public Douyin videos by keyword with sorting, time, duration, and content filters.

**Price:** \$12.00 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Douyin Video Search pricing and uptime](https://getanyapi.com/api/douyin/search-videos) - live USD price, lane routing, and measured 30-day uptime. [Every Douyin endpoint](https://getanyapi.com/api/douyin).

`POST /v1/run/douyin.search_videos`

**Cost:** Up to $0.01308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.01308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/ec410291-0cd4-481c-978c-722b0a02275f

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `backtrace` | string | No | Backtrace token returned by the previous page. |
| `cursor` | string | No | Pagination cursor: pass the previous response's nextCursor; omit for the first page. A raw integer cursor is still accepted. |
| `duration` | string | No | Duration filter in minutes: any, under 1, 1 to 5, or over 5. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `publishedWithin` | integer | No | Publication window in days. Use the canonical JSON integer 0 for any time, 1 for one day, 7 for seven days, or 180 for 180 days; legacy numeric strings remain accepted. |
| `query` | string | Yes | Keyword to search for. |
| `searchId` | string | No | Search ID returned by the previous page. |
| `sort` | string | No | Sort order: relevance (Douyin's comprehensive ranking), most-liked, date-posted. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/douyin.search_videos","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","backtrace":"<string>","cursor":"<string>","duration":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","publishedWithin":"<integer>","query":"<string>","searchId":"<string>","sort":"<string>","source":"<string>"}}'
```

### Douyin User Posts

List public posts from a Douyin user with normalized engagement data and pagination.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Douyin User Posts pricing and uptime](https://getanyapi.com/api/douyin/user-posts) - live USD price, lane routing, and measured 30-day uptime. [Every Douyin endpoint](https://getanyapi.com/api/douyin).

`POST /v1/run/douyin.user_posts`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/e92ea3ef-a727-430a-b376-c592c0e69d0d

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Pagination cursor: pass the previous response's nextCursor; omit for the first page. A raw integer cursor is still accepted. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Requested page size. Values up to 20 are recommended. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `secUserId` | string | Yes | Douyin sec_user_id for the public account. |
| `sort` | string | No | Post order: newest, most-popular. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/douyin.user_posts","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","ignoreSources":"<string>","limit":"<integer>","preferLatencyUnderMs":"<integer>","secUserId":"<string>","sort":"<string>","source":"<string>"}}'
```

### Douyin Video

Fetch a public Douyin video by share URL with normalized author and engagement data.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Douyin Video pricing and uptime](https://getanyapi.com/api/douyin/video) - live USD price, lane routing, and measured 30-day uptime. [Every Douyin endpoint](https://getanyapi.com/api/douyin).

`POST /v1/run/douyin.video`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/deea6b68-93ab-43f1-9748-1343f0d2da12

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Public Douyin video share URL. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/douyin.video","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### Douyin Video Comments

List public comments on a Douyin video with author and engagement data.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Douyin Video Comments pricing and uptime](https://getanyapi.com/api/douyin/video-comments) - live USD price, lane routing, and measured 30-day uptime. [Every Douyin endpoint](https://getanyapi.com/api/douyin).

`POST /v1/run/douyin.video_comments`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/4cf1a449-aede-486f-8125-910111168a39

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Pagination cursor: pass the previous response's nextCursor; omit for the first page. A raw integer cursor is still accepted. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `videoId` | string | Yes | Douyin aweme_id for the video. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/douyin.video_comments","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","videoId":"<string>"}}'
```

### Gemini Search

Ask Gemini a web-grounded question and receive an answer with source citations.

**Price:** \$2.00 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Gemini Search pricing and uptime](https://getanyapi.com/api/gemini/search) - live USD price, lane routing, and measured 30-day uptime. [Every Gemini endpoint](https://getanyapi.com/api/gemini).

`POST /v1/run/gemini.search`

**Cost:** Up to $0.005232 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.005232 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/a1a83ce8-fec5-40e0-8e82-924b3a9cfd48

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `prompt` | string | Yes | Question or research prompt for Gemini to answer using web search. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/gemini.search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","prompt":"<string>","source":"<string>"}}'
```

### DuckDuckGo Search

Run a DuckDuckGo web search and get the ranked organic results (title, URL, snippet, position, display URL, domain) as clean JSON, ads left out. Returns up to 10 results per call; page deeper with page and pick the country DuckDuckGo searches from.

**Price:** \$0.85 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 4 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [DuckDuckGo Search pricing and uptime](https://getanyapi.com/api/duckduckgo/search) - live USD price, lane routing, and measured 30-day uptime. [Every Duckduckgo endpoint](https://getanyapi.com/api/duckduckgo).

`POST /v1/run/duckduckgo.search`

**Cost:** Up to $0.000927 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.000927 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/e8549227-5396-4283-bd4b-903925f7e052

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `country` | string | No | ISO-3166 alpha-2 country DuckDuckGo searches from, e.g. US, GB, DE: DuckDuckGo's region for that country in its main language (Belgium in Dutch, Canada and the US in English, Switzerland in German, Spain in Spanish). Only the countries DuckDuckGo offers are accepted; every country is served by most sources and US, GB and DE by all of them. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum number of organic results to return (1-10, default 10). DuckDuckGo serves about 10 organic results per page, and some queries carry fewer. |
| `page` | integer | No | Which page of 10 results to return, starting at 1: page 2 returns results 11-20. Each page is billed as one request. Pages after the first are served only for country US, GB or DE, by the one source that continues each page exactly where the last ended. DuckDuckGo can repeat a result from the previous page, so deduplicate on url, and a limit below 10 drops the rest of that page. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | The DuckDuckGo search query. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/duckduckgo.search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","country":"<string>","ignoreSources":"<string>","limit":"<integer>","page":"<integer>","preferLatencyUnderMs":"<integer>","query":"<string>","source":"<string>"}}'
```

### eBay Product Full

Fetch one eBay listing by URL with the complete item-specifics table the seller filled in (MPN, model, capacity, compatibility and every other per-category attribute), the seller's full description, every listing image, and the seller's feedback record.

**Price:** \$1.80 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [eBay Product Full pricing and uptime](https://getanyapi.com/api/ebay/product-full) - live USD price, lane routing, and measured 30-day uptime. [Every Ebay endpoint](https://getanyapi.com/api/ebay).

`POST /v1/run/ebay.product_full`

**Cost:** Up to $0.001962 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001962 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/6cd48d0f-7b42-4f17-96bb-66fe869376d2

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Full eBay listing URL (e.g. https://www.ebay.com/itm/133576802017). Works on ended and sold listings as well as live ones, so it composes with ebay.sold_listings: pull the comps cheaply, then enrich the few you care about. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/ebay.product_full","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### eBay Search

Search eBay active listings by keyword with optional price-range, item-condition, listing-type, and sort filters and get title, price, condition, shipping, and seller in one normalized response.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [eBay Search pricing and uptime](https://getanyapi.com/api/ebay/search) - live USD price, lane routing, and measured 30-day uptime. [Every Ebay endpoint](https://getanyapi.com/api/ebay).

`POST /v1/run/ebay.search`

**Cost:** Up to $0.073139 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.073139 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/57d7106f-094a-4220-a68e-4d361df4c1cc

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `condition` | string | No | Filter by one or more item conditions; omit for all conditions (e.g. ["new", "open_box"]). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum number of results to return (1 to 25, default 25). |
| `listingType` | string | No | Restrict to a listing format; omit or use all for both (e.g. buy_it_now for fixed-price only). |
| `maxPrice` | integer | No | Optional maximum item price in USD. |
| `minPrice` | integer | No | Optional minimum item price in USD. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Search keywords, e.g. "nintendo switch" or "vintage levis 501". |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `sellerName`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a list |
| `sort` | string | No | Result sort order; omit for eBay's Best Match (e.g. price_low sorts by lowest price plus shipping first). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/ebay.search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","condition":"<string>","ignoreSources":"<string>","limit":"<integer>","listingType":"<string>","maxPrice":"<integer>","minPrice":"<integer>","preferLatencyUnderMs":"<integer>","query":"<string>","requireFields":"<string>","sort":"<string>","source":"<string>"}}'
```

### eBay Sold Listings

Retrieve recently sold eBay listings for any keyword with optional price-range, condition, category, sold-date, and sort filters, page by page (sold price, sale date, condition, seller, item details); ideal for pricing research.

**Price:** \$3.00 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [eBay Sold Listings pricing and uptime](https://getanyapi.com/api/ebay/sold-listings) - live USD price, lane routing, and measured 30-day uptime. [Every Ebay endpoint](https://getanyapi.com/api/ebay).

`POST /v1/run/ebay.sold_listings`

**Cost:** Up to $0.014715 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.014715 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/38cf0545-aff4-4a98-8925-c7a77a414fcd

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `categoryId` | string | No | Optional numeric eBay category id to search within (e.g. 9355 for Cell Phones & Smartphones, 9394 for Cell Phone Accessories). |
| `condition` | string | No | Item condition filter (e.g. used). |
| `endDate` | string | No | Only return listings sold on or before this date, inclusive, in YYYY-MM-DD format (e.g. 2026-09-15). This bound is applied to each page after it is fetched, so a page can hold fewer than limit listings, or none, while hasMore is still true: keep requesting the next page until hasMore is false. |
| `freeShipping` | boolean | No | Not supported by the current sources: only false (no filter) is accepted; true is refused without charge. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum number of results to return (1-60, default 25). |
| `listingType` | string | No | Restrict to a listing format; omit or use all for both (e.g. auction for auction sales only). |
| `maxPrice` | number | No | Optional maximum sold price in the site currency (e.g. 500). |
| `minPrice` | number | No | Optional minimum sold price in the site currency (e.g. 200). |
| `page` | integer | No | 1-based results page. Use with hasMore in the output to paginate, and keep query, filters, and limit the same while walking pages, because limit sets the page size. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Search keyword for sold items (e.g. iphone 13 pro). |
| `returnsAccepted` | boolean | No | Not supported by the current sources: only false (no filter) is accepted; true is refused without charge. |
| `seller` | string | No | Not supported by the current sources: a request that sets it is refused without charge. |
| `site` | string | No | eBay country site to search. Sold-listing coverage is currently US only. |
| `sort` | string | No | Result sort order; omitted means ended_recently (e.g. price_high sorts by highest sold price plus shipping first). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `startDate` | string | No | Only return listings sold on or after this date, inclusive, in YYYY-MM-DD format (e.g. 2026-09-01). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/ebay.sold_listings","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","categoryId":"<string>","condition":"<string>","endDate":"<string>","freeShipping":"<boolean>","ignoreSources":"<string>","limit":"<integer>","listingType":"<string>","maxPrice":"<number>","minPrice":"<number>","page":"<integer>","preferLatencyUnderMs":"<integer>","query":"<string>","returnsAccepted":"<boolean>","seller":"<string>","site":"<string>","sort":"<string>","source":"<string>","startDate":"<string>"}}'
```

### Spotify Podcast Episodes

List a Spotify podcast show's episodes with titles, durations, descriptions, and release dates by show URL or ID.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Spotify Podcast Episodes pricing and uptime](https://getanyapi.com/api/spotify/podcast-episodes) - live USD price, lane routing, and measured 30-day uptime. [Every Spotify endpoint](https://getanyapi.com/api/spotify).

`POST /v1/run/spotify.podcast_episodes`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/816eecab-5c59-43a1-8f6e-95ecf9720057

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Pagination cursor from a previous response for subsequent pages. |
| `id` | string | No | Spotify podcast show ID (alternative to url). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | No | Spotify podcast show URL (e.g. https://open.spotify.com/show/4rOoJ6Egrf8K2IrywzwOMk). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/spotify.podcast_episodes","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","id":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### GitHub Issue Comments

List the comments on a GitHub issue or pull request by its URL, oldest first, with each commenter's login, their relationship to the repository, reactions and the comment text.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [GitHub Issue Comments pricing and uptime](https://getanyapi.com/api/github/issue-comments) - live USD price, lane routing, and measured 30-day uptime. [Every Github endpoint](https://getanyapi.com/api/github).

`POST /v1/run/github.issue_comments`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/4613fd05-8316-4e8a-95a3-7057842047ab

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Pagination cursor from a previous response's nextCursor. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Rows per page, 1-100 (GitHub's own page-size limit). Each call returns one full page of this size; use nextCursor for the next page. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `authorAssociation` or `body`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be |
| `since` | string | No | Only comments updated on or after this date (YYYY-MM-DD). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | URL of a GitHub issue or pull request, e.g. https://github.com/openai/whisper/pull/1838. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/github.issue_comments","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","ignoreSources":"<string>","limit":"<integer>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","since":"<string>","source":"<string>","url":"<string>"}}'
```

### eBay Sold Listings (Basic)

Retrieve recently sold eBay listings for any keyword with the sold price, sale date, condition, format, bids, and whether a Best Offer was accepted, without seller details; the lighter sibling of eBay Sold Listings for price comps.

**Price:** \$3.00 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [eBay Sold Listings (Basic) pricing and uptime](https://getanyapi.com/api/ebay/sold-listings-thin) - live USD price, lane routing, and measured 30-day uptime. [Every Ebay endpoint](https://getanyapi.com/api/ebay).

`POST /v1/run/ebay.sold_listings_thin`

**Cost:** Up to $0.18094 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.18094 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/37de19f2-0731-496e-a42c-adf9b8c1d271

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `condition` | string | No | Item condition filter (e.g. used). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum number of results to return (1-60, default 25). |
| `listingType` | string | No | Restrict to a listing format; omit or use all for both (e.g. auction for auction sales only). |
| `maxPrice` | number | No | Optional maximum sold price in the site currency (e.g. 500). |
| `minPrice` | number | No | Optional minimum sold price in the site currency (e.g. 200). |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Search keyword for sold items (e.g. iphone 13 pro). |
| `site` | string | No | eBay country site to search. Sold-listing coverage is currently US only. |
| `sort` | string | No | Result sort order; omitted means ended_recently (e.g. price_high sorts by highest sold price plus shipping first). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/ebay.sold_listings_thin","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","condition":"<string>","ignoreSources":"<string>","limit":"<integer>","listingType":"<string>","maxPrice":"<number>","minPrice":"<number>","preferLatencyUnderMs":"<integer>","query":"<string>","site":"<string>","sort":"<string>","source":"<string>"}}'
```

### Etsy Product

Look up one Etsy listing by id and get its price, images, description, rating, reviews count, shop, category, variations, stock, ship-from country, favorites and materials in one normalized response.

**Price:** \$1.87 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Etsy Product pricing and uptime](https://getanyapi.com/api/etsy/product) - live USD price, lane routing, and measured 30-day uptime. [Every Etsy endpoint](https://getanyapi.com/api/etsy).

`POST /v1/run/etsy.product`

**Cost:** Up to $0.002038 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.002038 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/21f54c79-de66-4c11-acf2-2a8bc04b42d2

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `listingId` | string | Yes | Etsy listing id, the number in the listing URL (https://www.etsy.com/listing/<id>/...), e.g. 1810545592. The Etsy Search and Etsy Shop Listings SKUs return it as listingId. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `materials`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. Naming a combination that no single source r |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/etsy.product","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","listingId":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>"}}'
```

### Etsy Shop Listings

List one Etsy shop's active listings by shop name, a page at a time, and get title, price, original price and image for each listing in one normalized response.

**Price:** \$0.90 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Etsy Shop Listings pricing and uptime](https://getanyapi.com/api/etsy/shop-listings) - live USD price, lane routing, and measured 30-day uptime. [Every Etsy endpoint](https://getanyapi.com/api/etsy).

`POST /v1/run/etsy.shop_listings`

**Cost:** Up to $0.001014 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001014 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/2e61a4ab-b861-4f70-96a5-93f112a725ca

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `page` | integer | No | 1-based results page of the shop's listings. Each page is billed as one request. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `shopName` | string | Yes | Etsy shop name, as in the shop URL (https://www.etsy.com/shop/<name>), e.g. StudioStelleHD. The Etsy Search and Etsy Product SKUs return it as shopName. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/etsy.shop_listings","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","page":"<integer>","preferLatencyUnderMs":"<integer>","shopName":"<string>","source":"<string>"}}'
```

### Browse the API catalog

Every API AnyAPI can serve right now, with its normalized input and output contract's location, its USD pricing, and the sources behind it. Reading the catalog is free and needs no key. Each entry's `method` and `path` are the gateway's own authority on how to call it: use them rather than rebuilding a route from the slug. Schemas are omitted here to keep the response small; GET /v1/apis/{sku} returns them for one API.

`GET /catalog`

**Cost:** Free. Calls cost nothing.

**Page:** https://www.orthogonal.com/api/anyapi/dac2a4c7-11c1-498a-9291-2a738a8b2888

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `category` | string | No | Restrict the response to one category, using an entry's `category`. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/catalog","method":"GET","query":{"category":"<string>"}}'
```

### GitHub Repository

Fetch a GitHub repository's metadata by URL (stars, forks, language, topics, license, and timestamps).

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [GitHub Repository pricing and uptime](https://getanyapi.com/api/github/repository) - live USD price, lane routing, and measured 30-day uptime. [Every Github endpoint](https://getanyapi.com/api/github).

`POST /v1/run/github.repository`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/e6cf53b0-54ad-49e3-8a31-180b7ea1f697

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | GitHub repository URL (e.g. https://github.com/facebook/react). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/github.repository","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### Search the API catalog

Find an API by what you need rather than by its slug. Results are ranked, and `ranking` names the ranker that served them. A request must name `q`, `category`, or `platform`: a scope on its own is a complete question ("everything this platform can do"), while a request naming none of the three has nothing to answer and is rejected. Searching is free and needs no key. Feed a result's `slug` to GET /v1/apis/{sku} for its input schema before your first run.

`GET /catalog/search`

**Cost:** Free. Calls cost nothing.

**Page:** https://www.orthogonal.com/api/anyapi/23a9338b-724d-4785-ac1c-1f8682ea3a75

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `q` | string | No | What you need, in your own words. Long queries are truncated before ranking. |
| `category` | string | No | Restrict the response to one category, using an entry's `category`. |
| `platform` | string | No | Restrict results to one platform, using a result's `platformId`. |
| `limit` | integer | No | Maximum results in this response. Omit it for the ranked default. A value above the server's maximum is reduced to it rather than rejected, and `total` still reports how many matched. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/catalog/search","method":"GET","query":{"q":"<string>","category":"<string>","platform":"<string>","limit":"<integer>"}}'
```

### List the APIs you can run

The same catalog as GET /catalog, without measured source health, for a caller that is choosing an API to run rather than displaying uptime. Schemas are omitted; GET /v1/apis/{sku} returns them for one API.

`GET /v1/apis`

**Cost:** Free. Calls cost nothing.

**Page:** https://www.orthogonal.com/api/anyapi/2f7d549b-324c-41e5-b6f7-515b8093fdbb

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `category` | string | No | Restrict the response to one category, using an entry's `category`. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/apis","method":"GET","query":{"category":"<string>"}}'
```

### Get one API

One API's full contract: its normalized `inputSchema` and `outputSchema`, its USD pricing, the sources behind it, and its trailing-30-day latency distribution. Build your input from `inputSchema` rather than from the description: the schema is strict, so an invented field name fails the call. The latency percentiles are observations of past successful runs, not execution ceilings.

`GET /v1/apis/{sku}`

**Cost:** Free. Calls cost nothing.

**Page:** https://www.orthogonal.com/api/anyapi/45fc168f-8804-4435-8735-44b73d1d1033

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `sku` | string | Yes | Path parameter — substitute directly into the endpoint `path`. |

```bash
# Replace {sku} in "path" with real values before sending
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/apis/{sku}","method":"GET"}'
```

### Get a request

Inspect a customer-owned Request. Poll queued or running requests after retryAfterSeconds; a durable result stays collectable for 24 hours. A paid request's output can be read back for the account's response retention window, 3 days unless 7 days or none is chosen in the dashboard; lowering the setting hides older output at once. Reading kept output is limited per account to 30 reads a minute for each dollar of lifetime settled spend, so an account that has spent nothing cannot read it. Metadata remains after the result expires (resultExpired).

`GET /v1/requests/{id}`

**Cost:** Free. Calls cost nothing.

**Page:** https://www.orthogonal.com/api/anyapi/37fb7885-6cb5-489d-a48e-b44b85de5922

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `id` | string | Yes | Path parameter — substitute directly into the endpoint `path`. |

```bash
# Replace {id} in "path" with real values before sending
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/requests/{id}","method":"GET"}'
```

### Facebook Ad Details

Look up a single Meta Ad Library ad by ID or URL and get the advertiser, creative text, call-to-action, platforms, and run dates as clean JSON.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Facebook Ad Details pricing and uptime](https://getanyapi.com/api/facebook/ad-details) - live USD price, lane routing, and measured 30-day uptime. [Every Facebook endpoint](https://getanyapi.com/api/facebook).

`POST /v1/run/facebook.ad_details`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/e34624a8-2d29-4a9b-b286-5230329a475e

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `id` | string | No | Meta Ad Library ad ID (e.g. "702369045530963"). Provide either id or url. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | No | Meta Ad Library ad URL (e.g. "https://www.facebook.com/ads/library?id=1185617869915074"). Provide either id or url. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/facebook.ad_details","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","id":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### Facebook Post Transcript

Get the spoken-word transcript of any public Facebook video post by URL as normalized JSON.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Facebook Post Transcript pricing and uptime](https://getanyapi.com/api/facebook/post-transcript) - live USD price, lane routing, and measured 30-day uptime. [Every Facebook endpoint](https://getanyapi.com/api/facebook).

`POST /v1/run/facebook.post_transcript`

**Cost:** Up to $0.03488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.03488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/fcdf63a9-b985-49eb-a7d8-e9b05a924d53

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | The Facebook post or video URL. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/facebook.post_transcript","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### Facebook Profile

Fetch a Facebook page's public profile (likes, followers, category, about) by URL or handle.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Facebook Profile pricing and uptime](https://getanyapi.com/api/facebook/profile) - live USD price, lane routing, and measured 30-day uptime. [Every Facebook endpoint](https://getanyapi.com/api/facebook).

`POST /v1/run/facebook.profile`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/e98d7238-4e51-4b39-a7ed-26468c097497

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `handle` | string | No | Facebook page handle/username. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | No | Full Facebook page URL. profile.php without an id value names no page and is refused as invalid input, with no charge. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/facebook.profile","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","handle":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### Facebook Page Events

List upcoming and past events hosted by any public Facebook page by URL (name, schedule, venue, and host) as normalized JSON.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Facebook Page Events pricing and uptime](https://getanyapi.com/api/facebook/profile-events) - live USD price, lane routing, and measured 30-day uptime. [Every Facebook endpoint](https://getanyapi.com/api/facebook).

`POST /v1/run/facebook.profile_events`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/1bfa2c44-f584-4f5d-ac74-3c48b49e4f90

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Pagination cursor from a previous response. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | The Facebook page link whose events to list, e.g. https://www.facebook.com/brickyardoldtown. Accepted: facebook.com/<name>, /p/<name>-<id>, /pages/<name>/<id>, /pg/<name>, /people/<name>/<id> and profile.php?id=<id>, on facebook.com or fb.com with or without www, m, mbasic, web, business or a language subdomain. Anything after the page, such as a tab, is fine: only the page is read. Any other Facebook link, such as a single event, group, share link, reel, video, hashtag, search or login page, is |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/facebook.profile_events","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### Facebook Profile Posts

List a Facebook page's recent posts by URL or page id with cursor pagination (text, author, publication time, permalink).

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 4 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Facebook Profile Posts pricing and uptime](https://getanyapi.com/api/facebook/profile-posts) - live USD price, lane routing, and measured 30-day uptime. [Every Facebook endpoint](https://getanyapi.com/api/facebook).

`POST /v1/run/facebook.profile_posts`

**Cost:** Up to $0.007303 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.007303 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/5ef5c17c-c59a-45d9-b933-805d690b3f0e

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Pagination cursor from a previous response. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `pageId` | string | No | Facebook page id. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `shares`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a post tha |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | No | Facebook page or profile link, e.g. https://www.facebook.com/nike. Accepted: facebook.com/<name>, /p/<name>-<id>, /pages/<name>/<id>, /pg/<name>, /people/<name>/<id>, profile.php?id=<id>, and share links to a page (/share/<id> or /share/p/<id>), on facebook.com or fb.com with or without www, m, mbasic, web, business or a language subdomain. Anything after the page, such as a tab, is fine. Any other Facebook link, such as a single event, group, reel, video, video or reel share link (/share/v/ or |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/facebook.profile_posts","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","ignoreSources":"<string>","pageId":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>","url":"<string>"}}'
```

### GitHub User Following

List the GitHub users a given user follows by handle (each account's login, type, avatar, and profile URL) with pagination.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [GitHub User Following pricing and uptime](https://getanyapi.com/api/github/user-following) - live USD price, lane routing, and measured 30-day uptime. [Every Github endpoint](https://getanyapi.com/api/github).

`POST /v1/run/github.user_following`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/b79f2ce3-0483-4e69-a594-b25dd81d63ec

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Pagination cursor from a previous response (page number, defaults to 1). |
| `handle` | string | Yes | GitHub username. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/github.user_following","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","handle":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### GitHub Repository README

Get a GitHub repository's README by repository URL, as the Markdown text the maintainers wrote, with its file name, path and size. Use it to learn what a project does, which models and tools it uses, and how to reach its authors.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [GitHub Repository README pricing and uptime](https://getanyapi.com/api/github/repository-readme) - live USD price, lane routing, and measured 30-day uptime. [Every Github endpoint](https://getanyapi.com/api/github).

`POST /v1/run/github.repository_readme`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/ed8da52d-7e83-47e3-8552-aaeda1cc9d45

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `content` or `size`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | GitHub repository URL, e.g. https://github.com/openai/whisper. The README of the default branch is returned. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/github.repository_readme","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>","url":"<string>"}}'
```

### GitHub Issue and PR Search

Search issues and pull requests across GitHub with GitHub's own search syntax (repo:, is:pr, is:issue, author:, label:, created:...), with each result's author, state, labels, counts and body. Use it to find who opens issues and pull requests on a repository.

**Price:** \$2.40 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [GitHub Issue and PR Search pricing and uptime](https://getanyapi.com/api/github/search-issues) - live USD price, lane routing, and measured 30-day uptime. [Every Github endpoint](https://getanyapi.com/api/github).

`POST /v1/run/github.search_issues`

**Cost:** Up to $0.002616 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.002616 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/8ee3ea06-e090-4523-882b-77572e091ab1

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Rows per page, 1-100 (GitHub's own page-size limit). Keep it the same while walking pages, because it sets the page size. |
| `order` | string | No | Sort direction when sort is set. Defaults to desc. |
| `page` | integer | No | 1-based page of results. Request page + 1 while hasMore is true. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | GitHub issue search query with any of GitHub's qualifiers, e.g. "repo:openai/whisper is:pr", "is:issue label:bug author:octocat", "repo:ggml-org/llama.cpp is:pr is:merged created:>2026-01-01". |
| `sort` | string | No | Sort by number of comments, creation date, last update, or reactions. Omit for best match. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/github.search_issues","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","limit":"<integer>","order":"<string>","page":"<integer>","preferLatencyUnderMs":"<integer>","query":"<string>","sort":"<string>","source":"<string>"}}'
```

### GitHub Trending Developers

List trending GitHub developers (rank, username, name, avatar, and their most popular repository), optionally filtered by programming language and time range.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [GitHub Trending Developers pricing and uptime](https://getanyapi.com/api/github/trending-developers) - live USD price, lane routing, and measured 30-day uptime. [Every Github endpoint](https://getanyapi.com/api/github).

`POST /v1/run/github.trending_developers`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/379b7a6c-203a-4a25-ae9f-fc375c1e2c73

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `language` | string | No | Programming language to filter trending developers (e.g. javascript, python, go). |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `since` | string | No | Trending range: daily, weekly, or monthly (defaults to daily). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/github.trending_developers","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","language":"<string>","preferLatencyUnderMs":"<integer>","since":"<string>","source":"<string>"}}'
```

### GitHub Trending Repositories

List GitHub Trending repositories (rank, stars, stars gained today, language, and description), filterable by language and time window.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [GitHub Trending Repositories pricing and uptime](https://getanyapi.com/api/github/trending-repositories) - live USD price, lane routing, and measured 30-day uptime. [Every Github endpoint](https://getanyapi.com/api/github).

`POST /v1/run/github.trending_repositories`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/b5259f5e-a84a-437d-858a-da1f31d4dc6d

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `language` | string | No | Filter by programming language (e.g. "go", "typescript"). Omit for all languages. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `since` | string | No | Trending window. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/github.trending_repositories","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","language":"<string>","preferLatencyUnderMs":"<integer>","since":"<string>","source":"<string>"}}'
```

### GitHub User

Fetch a GitHub user's public profile by handle (name, bio, company, location, followers, and repo counts).

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [GitHub User pricing and uptime](https://getanyapi.com/api/github/user) - live USD price, lane routing, and measured 30-day uptime. [Every Github endpoint](https://getanyapi.com/api/github).

`POST /v1/run/github.user`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/2543214c-8b36-41e2-916d-3d9412a3fc2f

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `handle` | string | Yes | GitHub username. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/github.user","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","handle":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### Glassdoor Jobs

Search Glassdoor job listings by keyword and location, or scrape any Glassdoor company or job search page URL - up to 20 normalized job records per request.

**Price:** \$7.00 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Glassdoor Jobs pricing and uptime](https://getanyapi.com/api/glassdoor/jobs) - live USD price, lane routing, and measured 30-day uptime. [Every Glassdoor endpoint](https://getanyapi.com/api/glassdoor).

`POST /v1/run/glassdoor.jobs`

**Cost:** Up to $0.1199 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.1199 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/05d1bccc-39c5-411a-9eb5-2ed7de84a2f4

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `easyApply` | boolean | No | When true, only return jobs offering Easy Apply. Keyword mode only. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum number of results to return (1-20, default 20). |
| `location` | string | No | City, region, or country to search within (keyword mode; e.g. United States, New York). |
| `postedLimit` | string | No | Only jobs posted within this window (past 24 hours, week, or month). Keyword mode only. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | No | Job title or keywords to search (keyword mode). Provide this or a url. |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `companyIndustry` or `logoUrl`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still b |
| `sortBy` | string | No | Sort order: most recent (date) or best match (relevance). Keyword mode only. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | No | Alternatively, a Glassdoor company or job search page URL to scrape (e.g. https://www.glassdoor.com/Jobs/Google-Jobs-E9079.htm). The filters below apply in keyword (query) mode. |
| `workplaceType` | string | No | Filter by workplace type (remote, hybrid, or onsite). Keyword mode only. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/glassdoor.jobs","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","easyApply":"<boolean>","ignoreSources":"<string>","limit":"<integer>","location":"<string>","postedLimit":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","requireFields":"<string>","sortBy":"<string>","source":"<string>","url":"<string>","workplaceType":"<string>"}}'
```

### Google AI Mode

Ask Google AI Mode a prompt and receive the cited answer it generates. AI Mode composes the answer at search time, so repeat calls on one prompt can differ in wording and in which sources are cited.

**Price:** \$2.00 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Google AI Mode pricing and uptime](https://getanyapi.com/api/google/ai-mode) - live USD price, lane routing, and measured 30-day uptime. [Every Google endpoint](https://getanyapi.com/api/google).

`POST /v1/run/google.ai_mode`

**Cost:** Up to $0.00218 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.00218 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/9965d009-5a77-4168-8c4c-84b38f7a9da1

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `prompt` | string | Yes | The question or prompt to answer with Google AI Mode. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/google.ai_mode","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","prompt":"<string>","source":"<string>"}}'
```

### Google AI Overview

Ask Google Search a prompt and receive the AI Overview it generated for that scrape, with every source Google listed. Google regenerates the overview per search, so the same prompt can return different wording and a different source list.

**Price:** \$1.80 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Google AI Overview pricing and uptime](https://getanyapi.com/api/google/ai-overview) - live USD price, lane routing, and measured 30-day uptime. [Every Google endpoint](https://getanyapi.com/api/google).

`POST /v1/run/google.ai_overview`

**Cost:** Up to $0.005232 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.005232 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/4cf21682-9cd6-4739-b43e-bc157de39066

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `prompt` | string | Yes | The question or prompt to answer with a Google AI Overview. |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `scrapedAt`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. Naming a combination that no single source r |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/google.ai_overview","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","prompt":"<string>","requireFields":"<string>","source":"<string>"}}'
```

### Google AI Overview Preview

Ask Google Search a prompt and receive the AI Overview as a searcher first sees it, before selecting Show more: the opening text and the sources linked inside it. When Google shows the whole overview without a Show more button, that is what you receive. For the complete expanded overview with every source Google listed, use google.ai_overview.

**Price:** \$0.70 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Google AI Overview Preview pricing and uptime](https://getanyapi.com/api/google/ai-overview-preview) - live USD price, lane routing, and measured 30-day uptime. [Every Google endpoint](https://getanyapi.com/api/google).

`POST /v1/run/google.ai_overview_preview`

**Cost:** Up to $0.000763 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.000763 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/29a99d5d-1e0c-4ded-8425-e5e62cd9f5c1

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `prompt` | string | Yes | The question or prompt to search Google for. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/google.ai_overview_preview","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","prompt":"<string>","source":"<string>"}}'
```

### Google Autocomplete

Get Google search autocomplete suggestions for a partial query (keyword ideas).

**Price:** \$0.85 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Google Autocomplete pricing and uptime](https://getanyapi.com/api/google/autocomplete) - live USD price, lane routing, and measured 30-day uptime. [Every Google endpoint](https://getanyapi.com/api/google).

`POST /v1/run/google.autocomplete`

**Cost:** Up to $0.001079 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001079 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/0266a56f-fd1a-4cc0-aeb8-e98492e14287

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `gl` | string | No | Two-letter country code for result localization (e.g. us, gb, de). |
| `hl` | string | No | Two-letter interface and results language code for the suggestions (e.g. en, es, de). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | The partial Google search query. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/google.autocomplete","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","gl":"<string>","hl":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","source":"<string>"}}'
```

### Google Images

Run a Google Images search and get structured results: image URLs, dimensions, titles, and source pages.

**Price:** \$0.85 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Google Images pricing and uptime](https://getanyapi.com/api/google/images) - live USD price, lane routing, and measured 30-day uptime. [Every Google endpoint](https://getanyapi.com/api/google).

`POST /v1/run/google.images`

**Cost:** Up to $0.002158 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.002158 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/bb2abd12-bb97-49da-91bc-711721095a1c

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `autocorrect` | boolean | No | Toggle Google spelling autocorrect (default true). Set false to search the exact query without correction. |
| `gl` | string | No | Two-letter country code for result localization (e.g. us, gb, de). |
| `hl` | string | No | Two-letter interface and results language code (e.g. en, es, de). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum number of images to return (1-100, default 20). Requests for 10 results or fewer are billed at a lower rate than larger requests. |
| `location` | string | No | Fine-grained location for result localization, given as a canonical Google location string (e.g. 'New York, United States', 'London, United Kingdom'). More specific than the country-level gl. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Image search query (e.g. golden gate bridge at sunset). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `timeframe` | string | No | Restrict results to a recent time window: 1h, 1d, 7d, 1y, or all. Default all (no time restriction). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/google.images","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","autocorrect":"<boolean>","gl":"<string>","hl":"<string>","ignoreSources":"<string>","limit":"<integer>","location":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","source":"<string>","timeframe":"<string>"}}'
```

### Google Job

Fetch one Google Jobs listing by the listingToken that google.jobs returns: title, company, location, the site it was found on, the full description, apply links on every board that carries it, the posting details Google shows (posted, pay, job type, benefits), and the employer's ratings on review sites such as Glassdoor and Indeed when Google shows them.

**Price:** \$0.85 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Google Job pricing and uptime](https://getanyapi.com/api/google/job) - live USD price, lane routing, and measured 30-day uptime. [Every Google endpoint](https://getanyapi.com/api/google).

`POST /v1/run/google.job`

**Cost:** Up to $0.000927 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.000927 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/20040ce2-191f-41c2-9282-15e1a8a88727

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `listingToken` | string | Yes | The listingToken of one listing in a google.jobs response. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/google.job","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","listingToken":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### Google Jobs

Search Google Jobs, the job listings Google gathers from LinkedIn, Indeed, ZipRecruiter, company career sites and other boards, and get about 10 listings per call: title, company, location, the site it was found on, the full description, apply links on every board that carries it, and the posting details Google shows (posted, pay, job type, benefits). Each listing carries a listingToken you can pass to google.job for employer ratings. Send nextCursor back as cursor to walk further pages.

**Price:** \$0.85 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Google Jobs pricing and uptime](https://getanyapi.com/api/google/jobs) - live USD price, lane routing, and measured 30-day uptime. [Every Google endpoint](https://getanyapi.com/api/google).

`POST /v1/run/google.jobs`

**Cost:** Up to $0.000927 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.000927 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/e372f28c-52ad-4f23-bb81-c501637c2aa2

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Opaque cursor from a previous response's nextCursor. Send it with the same query, location, gl and hl to get the next page of about 10 listings; it expires about an hour after it was issued, after which you start again from page 1. |
| `gl` | string | No | Two-letter country code to search in (e.g. us, gb, de). |
| `hl` | string | No | Language code for the listings and their details (e.g. en, de, es). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `location` | string | No | City, region or country to search around, e.g. Chicago, IL or London. Google may include nearby places. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Job title or keywords to search, e.g. registered nurse. A place written into the query ("barista in Austin, TX") also localizes the search. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/google.jobs","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","gl":"<string>","hl":"<string>","ignoreSources":"<string>","location":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","source":"<string>"}}'
```

### Google Search

Run a Google web search and get the organic results (title, link, snippet, position) as clean JSON. Returns about 10 results per call - Google stopped honoring bulk result counts in September 2025, so a limit above 10 is accepted but returns no more than a page. Send page 2, 3, ... to walk further, or use google.search_100 for up to 100 ranked results in one call, which is normally cheaper past roughly 20 results.

**Price:** \$0.50 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Google Search pricing and uptime](https://getanyapi.com/api/google/search) - live USD price, lane routing, and measured 30-day uptime. [Every Google endpoint](https://getanyapi.com/api/google).

`POST /v1/run/google.search`

**Cost:** Up to $0.00218 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.00218 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/b0b84ccd-5989-4797-a8ed-c49d7a4582f0

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `autocorrect` | boolean | No | Toggle Google spelling autocorrect (default true). Set false to search the exact query without correction. |
| `cursor` | string | No | Deprecated: send page instead. A continuation token from an earlier response's nextCursor is still accepted and still continues on the source that issued it; page is ignored when cursor is sent alongside it. |
| `gl` | string | No | Two-letter country code for result localization (e.g. us, gb, de). |
| `hl` | string | No | Two-letter interface and results language code (e.g. en, es, de). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Page size to ask for. Google returns about 10 organic results per page and stopped honoring larger counts in September 2025, so a limit above 10 still returns about 10. Some sources return their whole page of about 10 whatever limit says: a page is never trimmed after the call, so nextCursor always continues exactly where this response ended. To go deeper, send page (about 10 results per page, each billed as a request) or use google.search_100, which returns up to 100 ranked results in a single |
| `location` | string | No | Fine-grained location to localize results to, more specific than the country-level gl. Send it as an Active Canonical Name from Google's geo-target list: place, then each parent region, then country, with no space after each comma, e.g. 'New York,New York,United States', 'Austin,Texas,United States', 'London,England,United Kingdom'. Common variations are translated to that name when they point to exactly one place: spaces after commas, missing accents, a US state abbreviation ('Orlando, FL, Unit |
| `page` | integer | No | Which page of about 10 organic results to return, starting at 1. Send page 2, 3, ... to walk deeper; each page is billed as one request and any source can serve any page. Replaces cursor. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | The Google search query. |
| `requireCursor` | boolean | No | Deprecated. Every source for this search returns a nextCursor, so this changes nothing about the price or which source serves you; it stays accepted so callers that already send it keep working. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `timeframe` | string | No | Restrict results to a recent time window: 1h, 1d, 7d, 1y, or all. Default all (no time restriction). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/google.search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","autocorrect":"<boolean>","cursor":"<string>","gl":"<string>","hl":"<string>","ignoreSources":"<string>","limit":"<integer>","location":"<string>","page":"<integer>","preferLatencyUnderMs":"<integer>","query":"<string>","requireCursor":"<boolean>","source":"<string>","timeframe":"<string>"}}'
```

### Google Videos

Search Google for video results (YouTube and others) with title, link, thumbnail, and source.

**Price:** \$0.85 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Google Videos pricing and uptime](https://getanyapi.com/api/google/videos) - live USD price, lane routing, and measured 30-day uptime. [Every Google endpoint](https://getanyapi.com/api/google).

`POST /v1/run/google.videos`

**Cost:** Up to $0.001079 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001079 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/7b5e52d3-e7bd-465b-8b43-75d8de29f953

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `autocorrect` | boolean | No | Toggle Google spelling autocorrect (default true). Set false to search the exact query without correction. |
| `gl` | string | No | Two-letter country code for result localization (e.g. us, gb, de). |
| `hl` | string | No | Two-letter interface and results language code (e.g. en, es, de). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `location` | string | No | Fine-grained location for result localization, given as a canonical Google location string (e.g. 'New York, United States', 'London, United Kingdom'). More specific than the country-level gl. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | The video search query. |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `source`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a record t |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `timeframe` | string | No | Restrict results to a recent time window: 1h, 1d, 7d, 1y, or all. Default all (no time restriction). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/google.videos","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","autocorrect":"<boolean>","gl":"<string>","hl":"<string>","ignoreSources":"<string>","location":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","requireFields":"<string>","source":"<string>","timeframe":"<string>"}}'
```

### Google Ads Ad Details

Look up a single Google Ads Transparency Center creative by URL and get its format, run dates, impression range, regions, and creative variations as clean JSON.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Google Ads Ad Details pricing and uptime](https://getanyapi.com/api/google-ads/ad-details) - live USD price, lane routing, and measured 30-day uptime. [Every Google Ads endpoint](https://getanyapi.com/api/google-ads).

`POST /v1/run/google_ads.ad_details`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/b0c60e66-9df4-4868-ba1a-fac6f076f5d9

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Google Ads Transparency Center creative URL (e.g. "https://adstransparency.google.com/advertiser/AR.../creative/CR..."). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/google_ads.ad_details","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### Google Ads Advertiser Search

Search the Google Ads Transparency Center for advertisers by keyword and get matching advertiser IDs, regions, and estimated ad counts as clean JSON.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Google Ads Advertiser Search pricing and uptime](https://getanyapi.com/api/google-ads/advertiser-search) - live USD price, lane routing, and measured 30-day uptime. [Every Google Ads endpoint](https://getanyapi.com/api/google-ads).

`POST /v1/run/google_ads.advertiser_search`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/a3f38d8a-4ce3-4d17-8767-e62456c859a5

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Advertiser name or keyword to search for (e.g. "lululemon"). |
| `region` | string | No | Two-letter country code to scope results (e.g. "AU", "CA"). Defaults to US. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/google_ads.advertiser_search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","region":"<string>","source":"<string>"}}'
```

### LinkedIn Article

Read a public LinkedIn article or newsletter issue by URL, including its full body text, author, publication time, and engagement counts.

**Price:** billed per result - \$5.69 per 1,000 requests base + \$0.00 per 1,000 results, capped at \$5.69 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [LinkedIn Article pricing and uptime](https://getanyapi.com/api/linkedin/article) - live USD price, lane routing, and measured 30-day uptime. [Every Linkedin endpoint](https://getanyapi.com/api/linkedin).

`POST /v1/run/linkedin.article`

**Cost:** Up to $0.006159 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.006159 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/7bb4aa4a-100b-4915-b029-9697aab3dca0

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Public LinkedIn article or newsletter issue URL, e.g. https://www.linkedin.com/pulse/your-article-slug. Pair it with the attachmentUrl returned by linkedin.search_posts_full to read the article behind a post. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/linkedin.article","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### Google Ads Company Ads

List the ads a company is running from the Google Ads Transparency Center by domain or advertiser ID (creative ID, format, ad URL, and first/last shown dates) with cursor pagination.

**Price:** \$0.85 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Google Ads Company Ads pricing and uptime](https://getanyapi.com/api/google-ads/company-ads) - live USD price, lane routing, and measured 30-day uptime. [Every Google Ads endpoint](https://getanyapi.com/api/google-ads).

`POST /v1/run/google_ads.company_ads`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/6386b080-40c3-4b30-ad32-24646f9de358

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `advertiserId` | string | No | Advertiser ID. Provide either domain or advertiserId. |
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Opaque pagination cursor from a previous response's nextCursor. |
| `domain` | string | No | Company domain (e.g. "lululemon.com"). Provide either domain or advertiserId. |
| `endDate` | string | No | Only return ads first shown on or before this date, format YYYY-MM-DD (e.g. 2024-12-31). |
| `format` | string | No | Ad format filter. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `platform` | string | No | Platform filter. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `region` | string | No | Two-letter country code to scope results (e.g. "US", "AU"). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `startDate` | string | No | Only return ads first shown on or after this date, format YYYY-MM-DD (e.g. 2024-01-01). |
| `topic` | string | No | Search topic. "political" requires a region. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/google_ads.company_ads","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"advertiserId":"<string>","allowFallbacks":"<boolean>","cursor":"<string>","domain":"<string>","endDate":"<string>","format":"<string>","ignoreSources":"<string>","platform":"<string>","preferLatencyUnderMs":"<integer>","region":"<string>","source":"<string>","startDate":"<string>","topic":"<string>"}}'
```

### Google Ads Transparency

Pull the ads an advertiser is running from the Google Ads Transparency Center (creative details, formats, run dates, and headline and text where Google publishes them) as clean JSON. Each ad's detail page is read, so a 20-ad call can take a minute or more; many text ads come back only as an image of the ad.

**Price:** billed per result - \$0.06 per 1,000 requests base + \$1.43 per 1,000 results, capped at \$28.70 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Google Ads Transparency pricing and uptime](https://getanyapi.com/api/google-ads/search) - live USD price, lane routing, and measured 30-day uptime. [Every Google Ads endpoint](https://getanyapi.com/api/google-ads).

`POST /v1/run/google_ads.search`

**Cost:** Up to $0.021691 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.021691 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/a887a973-103f-4386-ab82-c397d3f0cb2f

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum number of results to return (1-20, default 20). You are billed per result returned, so a lower limit costs less. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | A Google Ads Transparency Center URL for a selected advertiser or domain (e.g. https://adstransparency.google.com/advertiser/AR01614014350098432001?region=US). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/google_ads.search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","limit":"<integer>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### Google Finance Quote

Fetch a live quote for any stock, index, ETF, mutual fund, currency pair, or crypto symbol: name, current price, the absolute and percent change on the day, quote currency, exchange and market state, plus intraday and reference figures (open, day high/low, previous close, volume, market cap, and the 52-week range).

**Price:** billed per result - \$0.55 per 1,000 requests base + \$1.65 per 1,000 results, capped at \$2.20 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Google Finance Quote pricing and uptime](https://getanyapi.com/api/google-finance/quote) - live USD price, lane routing, and measured 30-day uptime. [Every Google Finance endpoint](https://getanyapi.com/api/google-finance).

`POST /v1/run/google_finance.quote`

**Cost:** Up to $0.001264 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001264 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/7c7ad1f5-7f41-4e31-89d6-04c900496007

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `symbol` | string | Yes | The symbol to quote. US stocks use a plain ticker (e.g. AAPL, TSLA); non-US stocks add a market suffix (e.g. VOW3.DE, BABA.HK, BARC.L); indices use a caret (e.g. ^GSPC, ^DJI); crypto and currencies use pair form (e.g. BTC-USD, EURUSD=X); mutual funds and futures use their symbol (e.g. VFIAX, ES=F). Common alternate forms are accepted and normalized (e.g. AAPL:NASDAQ, .DJI, BTC/USD). Exact symbols only, not a company-name search. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/google_finance.quote","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","symbol":"<string>"}}'
```

### Google Flights Search

Search Google Flights between two airports on a date and get about 20 itineraries: price, airline, stops, total duration, CO2 emissions against the typical figure for the route, and every leg's airline code, flight number, airports, local departure and arrival times and duration, as normalized JSON. Filter by cabin class, stops, airlines and maximum price. One-way searches return the total fare for all passengers. With a returnDate, each result is an outbound option priced at the cheapest round trip that starts with it (priceType round_trip_starting); the return flights are not included.

**Price:** \$1.00 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Google Flights Search pricing and uptime](https://getanyapi.com/api/google-flights/se

`POST /v1/run/google_flights.search`

**Cost:** Up to $0.000927 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.000927 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/5dad2364-5eac-4ec7-8ad8-a223417e230b

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `adults` | integer | No | Number of adult passengers (1-9, default 1). Prices are for all passengers together. |
| `airlines` | string | No | Only itineraries flown by these airlines, as two-character IATA codes (e.g. ["BA", "AA"]). |
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cabinClass` | string | No | Cabin class (default economy). |
| `children` | integer | No | Number of child passengers aged 2-11 (e.g. 1). |
| `currency` | string | No | ISO 4217 currency code for prices (e.g. USD, EUR, GBP; default USD). |
| `departureDate` | string | Yes | Departure date in YYYY-MM-DD format (e.g. 2027-01-12). Today or later. |
| `destination` | string | Yes | Arrival airport as a three-letter IATA code in capitals (e.g. LHR). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `maxPrice` | integer | No | Highest total price to return, in currency (e.g. 600). |
| `maxStops` | string | No | Most stops an itinerary may have (default any). |
| `origin` | string | Yes | Departure airport as a three-letter IATA code in capitals (e.g. JFK). |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `typicalCo2Kg`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on an i |
| `returnDate` | string | No | Return date in YYYY-MM-DD format for a round trip (e.g. 2027-01-19). Omit it for one way. With it, each result is an outbound option priced at the cheapest round trip that starts with it, and the return flights are not included. |
| `sortBy` | string | No | Result order: top_flights (Google's best flights first, the default), cheapest, departure_time, arrival_time, duration or emissions. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/google_flights.search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"adults":"<integer>","airlines":"<string>","allowFallbacks":"<boolean>","cabinClass":"<string>","children":"<integer>","currency":"<string>","departureDate":"<string>","destination":"<string>","ignoreSources":"<string>","maxPrice":"<integer>","maxStops":"<string>","origin":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","returnDate":"<string>","sortBy":"<string>","source":"<string>"}}'
```

### Google Hotel Details

Get one hotel from Google Hotels by its property ID: address, phone, website, rating, nightly price, prices from each booking site, amenities and check-in times as normalized JSON.

**Price:** \$1.50 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Google Hotel Details pricing and uptime](https://getanyapi.com/api/google-hotels/details) - live USD price, lane routing, and measured 30-day uptime. [Every Google Hotels endpoint](https://getanyapi.com/api/google-hotels).

`POST /v1/run/google_hotels.details`

**Cost:** Up to $0.005232 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.005232 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/18003633-cb59-4b7a-ac07-bb15deb96ece

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `adults` | integer | No | Number of adult guests (default 2). |
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `checkIn` | string | Yes | Check-in date in YYYY-MM-DD format (e.g. 2027-04-13). Today or later. |
| `checkOut` | string | Yes | Check-out date in YYYY-MM-DD format (e.g. 2027-04-15). After the check-in date. |
| `childrenAges` | integer | No | Age of each child guest, one entry per child (e.g. [5, 8] for two children aged 5 and 8). Omit it when no children are staying. |
| `country` | string | Yes | Two-letter lowercase ISO 3166-1 country code of the destination (e.g. us, pt, jp). It must be the country the hotels are in: results are searched from that country. |
| `currency` | string | No | ISO 4217 currency code for prices (e.g. USD, EUR, JPY; default USD). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `propertyToken` | string | Yes | Google Hotels property ID of the hotel, the propertyToken google_hotels.search returns for it. |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `stars` or `images`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/google_hotels.details","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"adults":"<integer>","allowFallbacks":"<boolean>","checkIn":"<string>","checkOut":"<string>","childrenAges":"<integer>","country":"<string>","currency":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","propertyToken":"<string>","requireFields":"<string>","source":"<string>"}}'
```

### Google Hotels Search

Search Google Hotels by destination and dates and get hotels with their Google property ID, nightly price, rating, review count, coordinates, star class and photos as normalized JSON.

**Price:** \$1.50 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Google Hotels Search pricing and uptime](https://getanyapi.com/api/google-hotels/search) - live USD price, lane routing, and measured 30-day uptime. [Every Google Hotels endpoint](https://getanyapi.com/api/google-hotels).

`POST /v1/run/google_hotels.search`

**Cost:** Up to $0.005232 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.005232 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/209a5959-4dd6-4f40-8ab6-210dafd99b31

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `adults` | integer | No | Number of adult guests (default 2). |
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `checkIn` | string | Yes | Check-in date in YYYY-MM-DD format (e.g. 2027-04-13). Today or later. |
| `checkOut` | string | Yes | Check-out date in YYYY-MM-DD format (e.g. 2027-04-15). After the check-in date. |
| `childrenAges` | integer | No | Age of each child guest, one entry per child (e.g. [5, 8] for two children aged 5 and 8). Omit it when no children are staying. |
| `country` | string | Yes | Two-letter lowercase ISO 3166-1 country code of the destination (e.g. us, pt, jp). It must be the country the hotels are in: results are searched from that country. |
| `currency` | string | No | ISO 4217 currency code for prices (e.g. USD, EUR, JPY; default USD). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | What to search for, usually a destination or landmark (e.g. hotels near times square new york). |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `totalPrice` or `amenities`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be a |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/google_hotels.search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"adults":"<integer>","allowFallbacks":"<boolean>","checkIn":"<string>","checkOut":"<string>","childrenAges":"<integer>","country":"<string>","currency":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","requireFields":"<string>","source":"<string>"}}'
```

### Google Shopping Search

Search Google Shopping by keyword and get up to 10 product offers (title, price, store, rating, and link), localized by country and language.

**Price:** \$18.00 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Google Shopping Search pricing and uptime](https://getanyapi.com/api/google-shopping/search) - live USD price, lane routing, and measured 30-day uptime. [Every Google Shopping endpoint](https://getanyapi.com/api/google-shopping).

`POST /v1/run/google_shopping.search`

**Cost:** Up to $0.069542 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.069542 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/81a74fe0-8261-4bcc-bfbb-747ad94d007f

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `condition` | string | No | Only return products in this condition (e.g. "USED"); defaults to any condition. |
| `country` | string | No | ISO 3166-1 alpha-2 country code for localized results (e.g. "us", "gb", "de"). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `language` | string | No | ISO 639-1 language code for results (e.g. "en", "es", "fr"). |
| `limit` | integer | No | Maximum number of results to return (1-10, default 10). |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Product name, brand, or keywords to search for (e.g. "Nike running shoes"). |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `listPriceText` or `discountPercent`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can s |
| `sortBy` | string | No | Sort order for results (e.g. "LOWEST_PRICE"); defaults to relevance. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/google_shopping.search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","condition":"<string>","country":"<string>","ignoreSources":"<string>","language":"<string>","limit":"<integer>","preferLatencyUnderMs":"<integer>","query":"<string>","requireFields":"<string>","sortBy":"<string>","source":"<string>"}}'
```

### Hacker News Profile

Get a Hacker News user's public profile by username - karma, bio, and account details as clean JSON.

**Price:** \$1.50 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Hacker News Profile pricing and uptime](https://getanyapi.com/api/hackernews/profile) - live USD price, lane routing, and measured 30-day uptime. [Every Hackernews endpoint](https://getanyapi.com/api/hackernews).

`POST /v1/run/hackernews.profile`

**Cost:** Up to $0.001635 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001635 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/0a55ce25-0c91-4a8f-bf90-6eb31884c6a2

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `handle` | string | Yes | Hacker News username, e.g. "pg". |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/hackernews.profile","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","handle":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### Hacker News Search

Search Hacker News by keyword - matching stories with title, link, author, points, and comment count as clean JSON.

**Price:** \$1.50 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Hacker News Search pricing and uptime](https://getanyapi.com/api/hackernews/search) - live USD price, lane routing, and measured 30-day uptime. [Every Hackernews endpoint](https://getanyapi.com/api/hackernews).

`POST /v1/run/hackernews.search`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/2f08634b-7d20-4ebd-80e5-ee95fe648b6d

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Search keyword, e.g. "ai". |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `tags` | string | No | Optional result filter, e.g. "story" or "comment". |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/hackernews.search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","source":"<string>","tags":"<string>"}}'
```

### Hacker News Story

Get a Hacker News story by id - title, link, author, points, and comment count as clean JSON.

**Price:** \$1.50 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Hacker News Story pricing and uptime](https://getanyapi.com/api/hackernews/story) - live USD price, lane routing, and measured 30-day uptime. [Every Hackernews endpoint](https://getanyapi.com/api/hackernews).

`POST /v1/run/hackernews.story`

**Cost:** Up to $0.001635 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001635 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/abe779c0-76c4-4551-9d9d-6439165ffe32

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `id` | string | Yes | Hacker News story id, e.g. "47340079". |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/hackernews.story","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","id":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### Indeed Jobs

Search Indeed job listings by keyword, location, and country, with up to 20 normalized job records per request.

**Price:** \$1.25 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Indeed Jobs pricing and uptime](https://getanyapi.com/api/indeed/jobs) - live USD price, lane routing, and measured 30-day uptime. [Every Indeed endpoint](https://getanyapi.com/api/indeed).

`POST /v1/run/indeed.jobs`

**Cost:** Up to $0.002518 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.002518 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/6c9131d8-1900-4592-bebe-a767581bb8ae

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `country` | string | No | Two-letter country site code (e.g. us, uk, de). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum number of results to return (1-20, default 20). |
| `location` | string | No | City, state, zip, or 'remote'. |
| `postedLimit` | string | No | Only return jobs posted within this window: 24h (past day) or week (past 7 days). Omit for all dates. This can raise your price: a dearer source serves a request that sets it, and you are quoted and charged its price. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Job search keywords (e.g. software engineer). |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `rating` or `streetAddress`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be a |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/indeed.jobs","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","country":"<string>","ignoreSources":"<string>","limit":"<integer>","location":"<string>","postedLimit":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","requireFields":"<string>","source":"<string>"}}'
```

### Instagram Reels by Audio

List Instagram reels that use a given audio track by audio id.

**Price:** \$1.10 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Instagram Reels by Audio pricing and uptime](https://getanyapi.com/api/instagram/audio-reels) - live USD price, lane routing, and measured 30-day uptime. [Every Instagram endpoint](https://getanyapi.com/api/instagram).

`POST /v1/run/instagram.audio_reels`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/17f78a62-a0eb-45e2-9883-51dff627fc10

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `audioId` | string | Yes | Audio identifier from the Instagram audio page URL. |
| `cursor` | string | No | Pagination cursor returned by a previous response. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `reshares`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a reel t |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/instagram.audio_reels","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","audioId":"<string>","cursor":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>"}}'
```

### Instagram Basic Profile

Fetch an Instagram account's core public profile fields (followers, posts, bio, verification) by user id.

**Price:** \$1.00 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 5 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Instagram Basic Profile pricing and uptime](https://getanyapi.com/api/instagram/basic-profile) - live USD price, lane routing, and measured 30-day uptime. [Every Instagram endpoint](https://getanyapi.com/api/instagram).

`POST /v1/run/instagram.basic_profile`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/9ba7ef16-4516-45b4-9031-b16688f66eab

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `posts`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a profile t |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `userId` | string | Yes | Instagram numeric user id (the account's internal all-digits id, e.g. 314216), NOT the @handle or profile URL. Passing a handle here returns no profile. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/instagram.basic_profile","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>","userId":"<string>"}}'
```

### Instagram Comment Replies

List the replies to an Instagram comment with cursor pagination (text, author, likes).

**Price:** \$1.10 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 4 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Instagram Comment Replies pricing and uptime](https://getanyapi.com/api/instagram/comment-replies) - live USD price, lane routing, and measured 30-day uptime. [Every Instagram endpoint](https://getanyapi.com/api/instagram).

`POST /v1/run/instagram.comment_replies`

**Cost:** Up to $0.002616 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.002616 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/8dbcbe77-9093-4129-8a50-f3b81ef6a949

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `commentId` | string | Yes | Instagram comment ID (a comment's id from the Instagram Post Comments endpoint). |
| `cursor` | string | No | Pagination cursor from a previous response's nextCursor. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Full Instagram post or reel URL the comment belongs to. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/instagram.comment_replies","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","commentId":"<string>","cursor":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### Instagram Profile Embed

Fetch the public embed HTML for an Instagram profile by handle.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Instagram Profile Embed pricing and uptime](https://getanyapi.com/api/instagram/embed) - live USD price, lane routing, and measured 30-day uptime. [Every Instagram endpoint](https://getanyapi.com/api/instagram).

`POST /v1/run/instagram.embed`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/43ed005d-d251-458b-a702-f7b019a4120b

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `handle` | string | Yes | Instagram username without the leading @. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/instagram.embed","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","handle":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### Instagram Followers

List about the first 50 followers of any public Instagram account by username: follower usernames, names, and profile details. Instagram caps follower lists, so this returns one page, not the whole list.

**Price:** \$1.73 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Instagram Followers pricing and uptime](https://getanyapi.com/api/instagram/followers) - live USD price, lane routing, and measured 30-day uptime. [Every Instagram endpoint](https://getanyapi.com/api/instagram).

`POST /v1/run/instagram.followers`

**Cost:** Up to $0.01744 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.01744 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/4b7deac5-da39-4e38-89a2-57d521087c20

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Opaque pagination cursor from a previous response's nextCursor. Today every source behind this endpoint returns a single page of about 50 followers and no continuation cursor, so nextCursor comes back empty and there is no further page to request; this parameter is accepted but has nothing to resume from. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `private`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a profile |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `username` | string | Yes | The Instagram username, user ID, or profile URL whose followers to list (e.g. natgeo). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/instagram.followers","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>","username":"<string>"}}'
```

### Instagram Following

List about the first 50 accounts a public Instagram user follows: usernames, names, and profile details. Instagram caps these lists, so this returns one page, not the whole list.

**Price:** \$1.73 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Instagram Following pricing and uptime](https://getanyapi.com/api/instagram/following) - live USD price, lane routing, and measured 30-day uptime. [Every Instagram endpoint](https://getanyapi.com/api/instagram).

`POST /v1/run/instagram.following`

**Cost:** Up to $0.01744 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.01744 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/425437f2-f813-4b0d-bed5-67dabb194294

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Opaque pagination cursor from a previous response's nextCursor. Today every source behind this endpoint returns a single page of about 50 accounts and no continuation cursor, so nextCursor comes back empty and there is no further page to request; this parameter is accepted but has nothing to resume from. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `private`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a profile |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `username` | string | Yes | The Instagram username, user ID, or profile URL whose following list to fetch (e.g. natgeo). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/instagram.following","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>","username":"<string>"}}'
```

### Instagram Hashtag Analytics

Get the total post count for any Instagram hashtag.

**Price:** \$1.10 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Instagram Hashtag Analytics pricing and uptime](https://getanyapi.com/api/instagram/hashtag-analytics) - live USD price, lane routing, and measured 30-day uptime. [Every Instagram endpoint](https://getanyapi.com/api/instagram).

`POST /v1/run/instagram.hashtag_analytics`

**Cost:** Up to $0.001199 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001199 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/5c55703a-5033-4ced-8284-1ba263835e89

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `hashtag` | string | Yes | The Instagram hashtag to analyze, with or without the # symbol (e.g. streetphotography). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Deprecated. Has no effect. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/instagram.hashtag_analytics","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","hashtag":"<string>","ignoreSources":"<string>","limit":"<integer>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### Instagram Hashtag Recent Posts

Instagram posts published under a hashtag, newest first, read from its live chronological feed rather than a web search index. Built for monitoring: results arrive within a couple of minutes of posting, so engagement counts are usually still zero and reels do not appear (Instagram keeps those on a separate tab). For engagement-ranked results use instagram.hashtag_top_posts; for older relevance-ranked results use instagram.search_hashtag.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Instagram Hashtag Recent Posts pricing and uptime](https://getanyapi.com/api/instagram/hashtag-recent-posts) - live USD price, lane routing, and measured 30-day uptime. [Every Instagram endpoint](https://getanyapi.com/api/instagram).

`POST /v1/run/instagram.hashtag_recent_posts`

**Cost:** Up to $0.002049 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.002049 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/cd164e09-e077-4412-8f91-16f0af7d565c

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Pagination cursor from a previous response's nextCursor. |
| `hashtag` | string | Yes | Hashtag to monitor, without the leading #. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/instagram.hashtag_recent_posts","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","hashtag":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### Instagram Hashtag Top Posts

Instagram's own top-ranked posts for a hashtag, read from its live hashtag feed rather than a web search index, with view, like, and comment counts. Reels-heavy and engagement-ranked, so it answers what is performing on a tag right now. For older relevance-ranked results with date and media-type filters use instagram.search_hashtag; for the chronological feed use instagram.hashtag_recent_posts.

**Price:** \$1.10 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Instagram Hashtag Top Posts pricing and uptime](https://getanyapi.com/api/instagram/hashtag-top-posts) - live USD price, lane routing, and measured 30-day uptime. [Every Instagram endpoint](https://getanyapi.com/api/instagram).

`POST /v1/run/instagram.hashtag_top_posts`

**Cost:** Up to $0.01744 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.01744 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/6e0e3cb4-d337-4c2d-a0c3-fb9f14f64332

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Pagination cursor from a previous response's nextCursor. |
| `hashtag` | string | Yes | Hashtag to fetch, without the leading #. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `soundTitle`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a post |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/instagram.hashtag_top_posts","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","hashtag":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>"}}'
```

### Instagram Highlight Detail

Fetch the details and media items of a single Instagram story highlight by id.

**Price:** \$1.10 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Instagram Highlight Detail pricing and uptime](https://getanyapi.com/api/instagram/highlight-detail) - live USD price, lane routing, and measured 30-day uptime. [Every Instagram endpoint](https://getanyapi.com/api/instagram).

`POST /v1/run/instagram.highlight_detail`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/1650faa3-9ee5-49f9-9697-78b7a3260fd1

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `id` | string | Yes | The id of the highlight to retrieve details for. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/instagram.highlight_detail","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","id":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### Instagram Location Posts

List public Instagram posts tagged at a location, ranked or most recent, with cursor pagination.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Instagram Location Posts pricing and uptime](https://getanyapi.com/api/instagram/location-posts) - live USD price, lane routing, and measured 30-day uptime. [Every Instagram endpoint](https://getanyapi.com/api/instagram).

`POST /v1/run/instagram.location_posts`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/3dc9d423-b614-4674-a49a-2dc1d9ce240b

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Pagination cursor from a previous response's nextCursor. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `locationId` | string | Yes | Instagram location id, as returned by instagram.search_locations. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `sort` | string | No | Order the posts by Instagram's top ranking or by newest first. Defaults to ranked. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/instagram.location_posts","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","ignoreSources":"<string>","locationId":"<string>","preferLatencyUnderMs":"<integer>","sort":"<string>","source":"<string>"}}'
```

### Instagram Media Transcript

Get the spoken-audio transcript text for an Instagram post or reel by URL.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Instagram Media Transcript pricing and uptime](https://getanyapi.com/api/instagram/media-transcript) - live USD price, lane routing, and measured 30-day uptime. [Every Instagram endpoint](https://getanyapi.com/api/instagram).

`POST /v1/run/instagram.media_transcript`

**Cost:** Up to $0.03488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.03488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/37d3fb73-cc98-430b-b38b-c63b493fa991

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `durationSeconds`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Instagram post or reel URL. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/instagram.media_transcript","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>","url":"<string>"}}'
```

### Instagram Profile Contact Info

Look up the contact email and phone number an Instagram creator or business publishes on its profile, including the address behind the profile's Email button that public profile lookups do not return.

**Price:** \$1.75 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 4 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Instagram Profile Contact Info pricing and uptime](https://getanyapi.com/api/instagram/profile-contact) - live USD price, lane routing, and measured 30-day uptime. [Every Instagram endpoint](https://getanyapi.com/api/instagram).

`POST /v1/run/instagram.profile_contact`

**Cost:** Up to $0.007859 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.007859 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/06bcb87a-77c7-4ae6-a24c-0dd0470aeee8

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `handle` | string | Yes | Instagram username without the leading @. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `isBusiness`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a prof |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/instagram.profile_contact","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","handle":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>"}}'
```

### Instagram Post

Fetch a single Instagram post or reel by URL (media URLs, like count, owner, type) as normalized JSON. Turn on hostVideo to also get the post's video on a hosted MP4 link that plays without an Instagram session, charged as an extra on top of the price. If you want the spoken words as well, instagram.reel_transcript transcribes the same reel.

**Price:** \$0.50 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 5 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Instagram Post pricing and uptime](https://getanyapi.com/api/instagram/post) - live USD price, lane routing, and measured 30-day uptime. [Every Instagram endpoint](https://getanyapi.com/api/instagram).

`POST /v1/run/instagram.post`

**Cost:** Up to $0.006954 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.006954 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/7a0ade96-6cb7-4b1f-9ea0-4d853f787ea0

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `hostVideo` | boolean | No | Set true to also get the post's video on a hosted MP4 link that plays without an Instagram session. The file is downloaded and stored for you, and the response adds `hostedUrl`, `expiresUtc` and `bytes`. It is charged as an extra on top of the price, and it never changes which source serves you: every source offers it at the same price. A post with no video, or a post that does not exist, is refused with no charge rather than billed for a file that cannot exist. Omit it and nothing is downloaded |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `plays`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a post that |
| `requirePlayCount` | boolean | No | Deprecated; send `requireFields: ["plays"]` instead, which does exactly the same thing. Set true to be served only by a source that reports a reel's play count. Omit it and routing is unchanged, with the cheapest source serving, which does not carry play counts, so `plays` is absent from its responses. This can raise your price: opting in routes to a source that reports the count, and you are quoted and charged its price. It stays accepted so callers that already send it keep working. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Full Instagram post or reel URL, carrying the media shortcode: /p/, /reel/, /reels/, or /tv/. A profile URL such as https://www.instagram.com/username names no post, so it is rejected instead of charged for an empty result - send that account's handle to instagram.profile, or its posts to instagram.user_posts. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/instagram.post","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","hostVideo":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","requirePlayCount":"<boolean>","source":"<string>","url":"<string>"}}'
```

### Instagram Post Comments

List the comments on an Instagram post or reel by URL with cursor pagination (text, author, likes).

**Price:** \$0.80 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 6 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Instagram Post Comments pricing and uptime](https://getanyapi.com/api/instagram/post-comments) - live USD price, lane routing, and measured 30-day uptime. [Every Instagram endpoint](https://getanyapi.com/api/instagram).

`POST /v1/run/instagram.post_comments`

**Cost:** Up to $0.01744 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.01744 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/50099dfc-18a0-439c-a486-6f92cd068269

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Pagination cursor from a previous response's nextCursor. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `replies`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a comment |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Full Instagram post or reel URL, carrying the media shortcode: /p/, /reel/, /reels/, or /tv/. A profile URL such as https://www.instagram.com/username names no post, so it is rejected instead of charged for an empty result - send that account's handle to instagram.user_posts to list its posts. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/instagram.post_comments","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>","url":"<string>"}}'
```

### Instagram Post Likers

List the accounts that liked a public Instagram post, one page of likers per call, with each liker's handle, display name, verified flag and avatar.

**Price:** \$1.10 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Instagram Post Likers pricing and uptime](https://getanyapi.com/api/instagram/post-likers) - live USD price, lane routing, and measured 30-day uptime. [Every Instagram endpoint](https://getanyapi.com/api/instagram).

`POST /v1/run/instagram.post_likers`

**Cost:** Up to $0.002616 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.002616 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/108f2407-a059-4495-bfd1-ebe64e23c776

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Canonical URL of a public Instagram post or reel. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/instagram.post_likers","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### Instagram Profile

Fetch an Instagram account's public profile (followers, posts, bio, verification) by handle.

**Price:** \$1.00 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 5 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Instagram Profile pricing and uptime](https://getanyapi.com/api/instagram/profile) - live USD price, lane routing, and measured 30-day uptime. [Every Instagram endpoint](https://getanyapi.com/api/instagram).

`POST /v1/run/instagram.profile`

**Cost:** Up to $0.002616 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.002616 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/bbc34de0-0321-4f5b-9bc0-7f33dacfc769

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `handle` | string | Yes | Instagram username without the leading @. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `contactMethod`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a p |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/instagram.profile","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","handle":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>"}}'
```

### Instagram Trending Reels

List currently trending Instagram reels. Instagram does not return play counts on this feed.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Instagram Trending Reels pricing and uptime](https://getanyapi.com/api/instagram/trending-reels) - live USD price, lane routing, and measured 30-day uptime. [Every Instagram endpoint](https://getanyapi.com/api/instagram).

`POST /v1/run/instagram.trending_reels`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/109871b8-1839-4171-8836-fb5b2bf39c48

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/instagram.trending_reels","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### Instagram Reel Transcript

Transcribe any public Instagram reel or video post: the full speech transcript, speaker labels, and word-level timestamps, from a reel, /p/, or /tv/ URL or an Instagram CDN media URL you already hold. A video post is transcribed exactly like a reel. A photo post comes back found with its record and an empty transcript, charged the request price only. Transcription runs on MAI-Transcribe-2, chosen for its accuracy and its speaker labels. Turn on hostVideo to also get the MP4 on a hosted link that plays without an Instagram session. If you only want the text, instagram.media_transcript is the cheaper transcript-only option; if you only want the file, instagram.post is where you go.

**Price:** billed per audio minute - \$1.50 per 1,000 requests base + \$6.00 per 1,000 audio minutes, capped at \$95.00 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:*

`POST /v1/run/instagram.reel_transcript`

**Cost:** Up to $0.108455 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.108455 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/d6da1ffd-4bcc-4ba9-9c6c-678269c6026b

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `hostVideo` | boolean | No | Set true to also get the reel's MP4 on a hosted link you can play without an Instagram session. Charged as an extra on top of the transcript (e.g. true). A photo post has no file to host, so a request that sets this on one is refused with no charge; send it without hostVideo to get the post record instead. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | The URL of a public Instagram reel or video post (e.g. https://www.instagram.com/reel/C8yKXdRxKqK/), or an Instagram CDN media URL you already hold. |
| `wordTimestamps` | boolean | No | Set true to include a precise timestamp for every word in the transcript (e.g. true). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/instagram.reel_transcript","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","hostVideo":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>","wordTimestamps":"<boolean>"}}'
```

### Instagram Reels Search

Search Instagram Reels by keyword against Instagram's own reels search and get matching reels with view, like and comment counts, caption, creator and duration. Results are relevance-ranked, not chronological. We remove overlap with recent pages, but older reels may reappear during a long search. nextCursor is null when a page contains only reels seen in recent pages. For a web-search-index view of the same keyword, with a recency filter and numbered pages, use instagram.web_reels_search.

**Price:** \$1.10 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Instagram Reels Search pricing and uptime](https://getanyapi.com/api/instagram/reels-search) - live USD price, lane routing, and measured 30-day uptime. [Every Instagram endpoint](https:

`POST /v1/run/instagram.reels_search`

**Cost:** Up to $0.002616 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.002616 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/34fde210-377f-4028-a342-d1c56af95f30

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Pagination cursor from a previous response's nextCursor. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Search keyword (e.g. "crossfit"). |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `locationName`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a re |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/instagram.reels_search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","requireFields":"<string>","source":"<string>"}}'
```

### Instagram Search

Search Instagram for users, hashtags, or places by keyword and get matching results with names, counts, and links.

**Price:** \$3.60 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Instagram Search pricing and uptime](https://getanyapi.com/api/instagram/search) - live USD price, lane routing, and measured 30-day uptime. [Every Instagram endpoint](https://getanyapi.com/api/instagram).

`POST /v1/run/instagram.search`

**Cost:** Up to $0.03597 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.03597 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/e549d119-87bd-4728-a156-dd68170d40d2

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum number of results to return (1-20, default 20). |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Keyword to search Instagram for; one or more words without special punctuation (e.g. coffee roastery). |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `postsCount`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a prof |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `type` | string | No | What to search for: user profiles, hashtags, or places (e.g. hashtag). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/instagram.search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","limit":"<integer>","preferLatencyUnderMs":"<integer>","query":"<string>","requireFields":"<string>","source":"<string>","type":"<string>"}}'
```

### Instagram Search Followers

Search the followers of a public Instagram account by name or username, using Instagram's own follower search. On smaller accounts it searches the whole follower list and returns close matches ranked by Instagram. On large accounts Instagram does not support searching followers, so the result is the account's most recent followers instead, whatever the query. Returns usernames, names, and profile details.

**Price:** \$2.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Instagram Search Followers pricing and uptime](https://getanyapi.com/api/instagram/search-followers) - live USD price, lane routing, and measured 30-day uptime. [Every Instagram endpoint](https://getanyapi.com/api/instagram).

`POST /v1/run/instagram.search_followers`

**Cost:** Up to $0.002398 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.002398 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/20ca8628-bf11-4bb8-aed1-786be760dd1b

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Name or username text to look for among this account's followers (e.g. john). Instagram matches loosely, and on large accounts it does not search followers at all, so the most recent followers come back instead. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `username` | string | Yes | The Instagram username whose followers to search, without the leading @ (e.g. milada2788). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/instagram.search_followers","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","source":"<string>","username":"<string>"}}'
```

### Instagram Search Following

Search the accounts a public Instagram user follows by name or username. Matching is Instagram's own loose search, so results are close matches ranked by Instagram and some may not contain your exact word. Returns usernames, names, and profile details.

**Price:** \$2.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Instagram Search Following pricing and uptime](https://getanyapi.com/api/instagram/search-following) - live USD price, lane routing, and measured 30-day uptime. [Every Instagram endpoint](https://getanyapi.com/api/instagram).

`POST /v1/run/instagram.search_following`

**Cost:** Up to $0.002398 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.002398 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/91618a2f-aabc-4c17-85e3-062677d07dca

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Name or username text to look for among the accounts this user follows (e.g. skin). Instagram matches loosely, so close matches are returned too. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `username` | string | Yes | The Instagram username whose following list to search, without the leading @ (e.g. moogooskincare). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/instagram.search_following","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","source":"<string>","username":"<string>"}}'
```

### Instagram Hashtag Search

Search posts under an Instagram hashtag through a web search index rather than Instagram's own hashtag feed. That is what lets it filter by date and media type and return reels whose like counts have settled, and it is also why results skew older (median around three months) and stop at roughly 110 per hashtag. For Instagram's own live ranking of a tag use instagram.hashtag_top_posts, and for the chronological feed use instagram.hashtag_recent_posts.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Instagram Hashtag Search pricing and uptime](https://getanyapi.com/api/instagram/search-hashtag) - live USD price, lane routing, and measured 30-day uptime. [Every Instagram endpoint](https://getanyapi.com/api/instagram).

`POST /v1/run/instagram.search_hashtag`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/98bd79a7-8fda-4da0-90e3-ad472504aaa8

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Pagination cursor from a previous response. |
| `datePosted` | string | No | Restrict results to posts published within this window. |
| `hashtag` | string | Yes | Hashtag to search, without the leading #. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `mediaType` | string | No | Filter by media type. One of all, reel. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/instagram.search_hashtag","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","datePosted":"<string>","hashtag":"<string>","ignoreSources":"<string>","mediaType":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### Instagram Location Search

Search Instagram locations by keyword and return each place's id, name, address and coordinates.

**Price:** \$1.10 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Instagram Location Search pricing and uptime](https://getanyapi.com/api/instagram/search-locations) - live USD price, lane routing, and measured 30-day uptime. [Every Instagram endpoint](https://getanyapi.com/api/instagram).

`POST /v1/run/instagram.search_locations`

**Cost:** Up to $0.002616 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.002616 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/3b306d0d-199f-40ba-a832-7cbfee541066

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Place name, address or city to search for. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/instagram.search_locations","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","source":"<string>"}}'
```

### Instagram Profile Search

Search public Instagram profiles by a bio or caption keyword.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Instagram Profile Search pricing and uptime](https://getanyapi.com/api/instagram/search-profiles) - live USD price, lane routing, and measured 30-day uptime. [Every Instagram endpoint](https://getanyapi.com/api/instagram).

`POST /v1/run/instagram.search_profiles`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/67d5d92c-3dd3-4a34-ae46-edfaf980fad6

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Pagination cursor returned by a previous response. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Bio or caption keyword/phrase to search for. |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `private`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a profile |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/instagram.search_profiles","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","requireFields":"<string>","source":"<string>"}}'
```

### Google Play Search

Search Google Play for Android apps by keyword, in any store country: package name, title, developer, rating, installs, price, and category for each result.

**Price:** \$0.85 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Google Play Search pricing and uptime](https://getanyapi.com/api/playstore/search) - live USD price, lane routing, and measured 30-day uptime. [Every Playstore endpoint](https://getanyapi.com/api/playstore).

`POST /v1/run/playstore.search`

**Cost:** Up to $0.000927 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.000927 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/eb090c9e-abce-44fe-88fc-ccd73d007735

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `country` | string | No | Two-letter Google Play store country code to search (e.g. gb); results, prices, and currency follow that country. Text is returned in English. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum number of apps to return in items (1-30, default 20). Google Play shows about 30 apps per search, so fewer may come back. The app Google Play features above the results comes back separately in featuredApps and does not count toward this limit. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Search keywords, as typed into the Google Play search box (e.g. budget tracker). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/playstore.search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","country":"<string>","ignoreSources":"<string>","limit":"<integer>","preferLatencyUnderMs":"<integer>","query":"<string>","source":"<string>"}}'
```

### Instagram Profile Search with Contact

Search public Instagram profiles by a bio or caption keyword and get each account's country, the month it joined, and the public email and phone number it lists. Charged per profile that comes back with those details.

**Price:** billed per profile - \$3.60 per 1,000 requests base + \$7.20 per 1,000 profiles, capped at \$90.00 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Instagram Profile Search with Contact pricing and uptime](https://getanyapi.com/api/instagram/search-profiles-contact) - live USD price, lane routing, and measured 30-day uptime. [Every Instagram endpoint](https://getanyapi.com/api/instagram).

`POST /v1/run/instagram.search_profiles_contact`

**Cost:** Up to $0.0872 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.0872 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/ff1043a7-2201-42b0-a383-b5986453dd0e

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Pagination cursor returned by a previous response. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Most profiles to return on this page, 1 to 12. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Bio or caption keyword/phrase to search for. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/instagram.search_profiles_contact","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","ignoreSources":"<string>","limit":"<integer>","preferLatencyUnderMs":"<integer>","query":"<string>","source":"<string>"}}'
```

### Instagram Similar Profiles

List the accounts Instagram recommends as similar to a public profile, with each account's handle, display name, verified flag and avatar.

**Price:** \$1.75 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Instagram Similar Profiles pricing and uptime](https://getanyapi.com/api/instagram/similar-profiles) - live USD price, lane routing, and measured 30-day uptime. [Every Instagram endpoint](https://getanyapi.com/api/instagram).

`POST /v1/run/instagram.similar_profiles`

**Cost:** Up to $0.002398 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.002398 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/a6849441-a4c6-495c-9174-914a2010fbd5

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `handle` | string | Yes | Instagram username without the leading @. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/instagram.similar_profiles","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","handle":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### Instagram Stories (full)

Fetch a public Instagram account's currently live stories with media, type, dimensions, posting time, and 24-hour expiry by username.

**Price:** \$2.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Instagram Stories (full) pricing and uptime](https://getanyapi.com/api/instagram/stories-full) - live USD price, lane routing, and measured 30-day uptime. [Every Instagram endpoint](https://getanyapi.com/api/instagram).

`POST /v1/run/instagram.stories_full`

**Cost:** Up to $0.002616 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.002616 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/6f10f9ef-31f2-4a92-8712-641ec8f781a3

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `soundTitle`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a stor |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `username` | string | Yes | Instagram username or handle without the @. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/instagram.stories_full","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>","username":"<string>"}}'
```

### Instagram Stories (basic)

Fetch a public Instagram account's currently live stories - media URL, owner, and posting time - by username. Lightweight projection; for media type, dimensions, and the 24h expiry time use instagram.stories_full.

**Price:** \$1.88 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Instagram Stories (basic) pricing and uptime](https://getanyapi.com/api/instagram/stories-thin) - live USD price, lane routing, and measured 30-day uptime. [Every Instagram endpoint](https://getanyapi.com/api/instagram).

`POST /v1/run/instagram.stories_thin`

**Cost:** Up to $0.01744 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.01744 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/4a66f755-2a94-4580-bf7b-d9d897482223

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `durationSeconds`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `username` | string | Yes | Instagram username/handle to fetch currently live stories for (without the @). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/instagram.stories_thin","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>","username":"<string>"}}'
```

### Instagram Tagged Posts

List the posts an Instagram user is tagged in, with cursor pagination (author, caption, likes, comments).

**Price:** \$1.88 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Instagram Tagged Posts pricing and uptime](https://getanyapi.com/api/instagram/tagged-posts) - live USD price, lane routing, and measured 30-day uptime. [Every Instagram endpoint](https://getanyapi.com/api/instagram).

`POST /v1/run/instagram.tagged_posts`

**Cost:** Up to $0.002616 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.002616 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/28b1cab0-e731-4c44-b278-87b5747f53b5

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Pagination cursor from a previous response's nextCursor. |
| `handle` | string | Yes | Instagram username without the leading @. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `audioId`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a post th |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/instagram.tagged_posts","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","handle":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>"}}'
```

### Instagram User Highlights

List an Instagram account's story highlight reels by handle.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Instagram User Highlights pricing and uptime](https://getanyapi.com/api/instagram/user-highlights) - live USD price, lane routing, and measured 30-day uptime. [Every Instagram endpoint](https://getanyapi.com/api/instagram).

`POST /v1/run/instagram.user_highlights`

**Cost:** Up to $0.001788 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001788 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/2c9c1153-fb54-4565-99ad-86859de605dd

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `handle` | string | Yes | Instagram username without the leading @. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `mediaCount`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a high |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `userId` | string | No | Instagram numeric user id (optional, faster than handle). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/instagram.user_highlights","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","handle":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>","userId":"<string>"}}'
```

### Instagram User Posts

List an Instagram account's recent posts (likes, comments, captions) by handle with cursor pagination.

**Price:** \$0.80 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 7 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Instagram User Posts pricing and uptime](https://getanyapi.com/api/instagram/user-posts) - live USD price, lane routing, and measured 30-day uptime. [Every Instagram endpoint](https://getanyapi.com/api/instagram).

`POST /v1/run/instagram.user_posts`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/371e3faf-7435-4998-8b4d-65f2e12d8fe4

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Pagination cursor from a previous response's nextCursor. |
| `handle` | string | Yes | Instagram username without the leading @. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `userId`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a post tha |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/instagram.user_posts","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","handle":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>"}}'
```

### Instagram User Reels

List an Instagram account's reels by handle with cursor pagination (caption, plays, likes, comments).

**Price:** \$0.80 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 7 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Instagram User Reels pricing and uptime](https://getanyapi.com/api/instagram/user-reels) - live USD price, lane routing, and measured 30-day uptime. [Every Instagram endpoint](https://getanyapi.com/api/instagram).

`POST /v1/run/instagram.user_reels`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/87bae709-ed68-46e0-9297-823e534aecb3

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Pagination cursor (max_id) from a previous response's nextCursor. |
| `handle` | string | No | Instagram handle. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `soundTitle`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a reel |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `userId` | string | No | Instagram user id (faster than handle when known). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/instagram.user_reels","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","handle":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>","userId":"<string>"}}'
```

### Instagram User Reposts

List the posts a public Instagram account has reposted to its feed, with cursor pagination.

**Price:** \$1.10 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Instagram User Reposts pricing and uptime](https://getanyapi.com/api/instagram/user-reposts) - live USD price, lane routing, and measured 30-day uptime. [Every Instagram endpoint](https://getanyapi.com/api/instagram).

`POST /v1/run/instagram.user_reposts`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/8d0abed2-8fda-4fa3-a23f-903fefb6cbb3

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Pagination cursor from a previous response's nextCursor. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `userId` | string | Yes | Instagram's numeric account id, as returned by instagram.profile. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/instagram.user_reposts","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","userId":"<string>"}}'
```

### Instagram Reels Web Search

Search Instagram Reels through a web search index rather than Instagram's own search, and get matching reels (caption, likes, comments, creator, and duration). That is what lets it filter by a recency window and page by number, and it is also why the results are whatever the index has crawled rather than what Instagram ranks right now, and why paging tops out around 110 reels per query (11 pages of 10). Instagram does not return view or play counts here. For Instagram's own live reels search, with view counts, use instagram.reels_search.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Instagram Reels Web Search pricing and uptime](https://getanyapi.com/api/instagram/web-reels-search) - live USD price, lane routing, and measured 30-day uptime. [Every Instagram endp

`POST /v1/run/instagram.web_reels_search`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/e277f3bc-88f7-4a3e-b698-4b5c0bf7d28f

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `datePosted` | string | No | Recency hint, not a hard filter. Reel discovery runs on top of Google search, so this window narrows Google's index by when it discovered or last crawled the reel, which is not the same as when the reel was published to Instagram. Returned reels can have a createdUtc outside the requested window, and the narrowest window, last-week, often returns older reels or no results. Check createdUtc yourself if you need exact publication-time precision. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `page` | integer | No | 1-based results page. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Search keyword (e.g. "crossfit"). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/instagram.web_reels_search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","datePosted":"<string>","ignoreSources":"<string>","page":"<integer>","preferLatencyUnderMs":"<integer>","query":"<string>","source":"<string>"}}'
```

### Job Search - TheirStack

Search TheirStack's job-post index by company, technology, keyword, title, seniority, salary, location and how recently the post appeared, and get the hiring company's full firmographic record with every post. Billed per job returned.

**Price:** billed per result - \$67.20 per 1,000 results, capped at \$9,945.60 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Job Search - TheirStack pricing and uptime](https://getanyapi.com/api/job-search/theirstack) - live USD price, lane routing, and measured 30-day uptime. [Every Job_search endpoint](https://getanyapi.com/api/job-search).

`POST /v1/run/job_search.theirstack`

**Cost:** Up to $10.840704 per call. Response-based: the price is worked out from the usage reported in the response, never more than $10.840704 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/c76381e9-03d1-4873-b327-7d5ebb8bd761

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `companyCountryCodeNot` | string | No | Return companies whose HQ country code is not any of the ones passed here, case sensitive. Pass ISO2 country codes. |
| `companyCountryCodeOr` | string | No | Return companies whose HQ country code is any of the ones passed here, case sensitive. Pass ISO2 country codes. |
| `companyDescriptionPatternAccentInsensitive` | boolean | No | Set to True to make company description searches accent insensitive. For example, "á" will match "a" as well. |
| `companyDescriptionPatternNot` | string | No | Case-insensitive patterns to match in the company description. Will return companies that match any of the patterns. |
| `companyDescriptionPatternOr` | string | No | Case-insensitive patterns to match in the company description. Will return companies that match any of the patterns. |
| `companyDomainNot` | string | No | Only return companies that don't match these domains exactly. It accepts full urls (https://www.google.com/) and emails (john.polo@gmail.com). |
| `companyDomainOr` | string | No | Only return companies that match these domains exactly. It accepts full urls (https://www.google.com/) and emails (john.polo@gmail.com). This filter acts as an OR filter, so if you pass more than one company domain, it will return companies that match any of the domains. |
| `companyIdOr` | string | No | Only return companies that match these IDs exactly. This filter acts as an OR filter, so if you pass more than one company ID, it will return companies that match any of the IDs. |
| `companyInvestorsOr` | string | No | Investors of the company |
| `companyInvestorsPartialMatchOr` | string | No | Investors of the company. Will return companies for which any of their investors contains any of the substrings passed here. For example, if you pass 'andree', all funds that match it (like 'Andreessen Horowitz', 'Andreessen Horowitz LLC', etc). |
| `companyKeywordSlugAnd` | string | No | Return results from companies that have mentioned all of these keywords in their jobs. Case sensitive. Pass slugs. Check out all the keywords we track at GET /v0/catalog/keywords |
| `companyKeywordSlugNot` | string | No | Return results from companies that haven't mentioned any of these keywords in their jobs. Case sensitive. Pass slugs. Check out all the keywords we track at GET /v0/catalog/keywords |
| `companyKeywordSlugOr` | string | No | Return results from companies that have mentioned any of these keywords in their jobs. Case sensitive. Pass slugs. Check out all the keywords we track at GET /v0/catalog/keywords |
| `companyLinkedinUrlExists` | boolean | No | (Use `property_exists_or / property_exists_and` instead) Only return companies with a LinkedIn URL |
| `companyLinkedinUrlOr` | string | No | Return companies whose LinkedIn URL matches any of the slugs passed here. Can also pass full LinkedIn company URLs. |
| `companyListIdNot` | string | No | Return companies that don't belong to any of the company lists passed here |
| `companyListIdOr` | string | No | Return companies that belong to any of the company lists passed here |
| `companyLocationPatternOr` | string | No | Return companies whose city matches any of the patterns passed here. Case insensitive. For example, if you pass 'san francisco', it will return companies whose city is 'San Francisco', 'San Francisco Bay Area', etc. |
| `companyNameCaseInsensitiveOr` | string | No | Only return companies that match these names exactly, case-insensitively. |
| `companyNameNot` | string | No | Only return companies that don't match these names exactly, case-sensitively. |
| `companyNameOr` | string | No | Only return companies that match these names exactly, case-sensitively. This filter acts as an OR filter, so if you pass more than one company name, it will return companies that match any of the names. |
| `companyNamePartialMatchNot` | string | No | Company names. Will return companies whose name doesn't contain any of the the substrings passed here, case-insensitively. For example, if you pass 'google', it will exclude 'Google', 'Google LLC', 'Google Inc', etc. |
| `companyNamePartialMatchOr` | string | No | Company names. Will return companies whose name contain any of the the substrings passed here, case-insensitively. For example, if you pass "google", it will return "Google", "Google LLC", "Google Inc", etc. |
| `companyTagsOr` | string | No | Return companies that match any of these keywords |
| `companyTechnologySlugAnd` | string | No | Will return jobs from companies that that have mentioned all of these technologies in their jobs (not necessarily in the jobs returned). Case sensitive. Pass slugs. Check out all the technologies we track at GET /v0/catalog/technologies. Deprecated: use company_keyword_slug_and instead. |
| `companyTechnologySlugNot` | string | No | Will return jobs from companies that that haven't mentioned any of these technologies in their jobs. Case sensitive. Pass slugs. Check out all the technologies we track at GET /v0/catalog/technologies. Deprecated: use company_keyword_slug_not instead. |
| `companyTechnologySlugOr` | string | No | Will return jobs from companies that that have mentioned any of these technologies in their jobs (not necessarily in the jobs returned). Case sensitive. Pass slugs. Check out all the technologies we track at GET /v0/catalog/technologies. Deprecated: use company_keyword_slug_or instead. |
| `companyType` | string | No | Filter by company type. |
| `discoveredAtGte` | string | No | Only jobs discovered by TheirStack on this date or datetime or after will be returned. In UTC timezone. |
| `discoveredAtLte` | string | No | Only jobs discovered by TheirStack on this date or datetime or before will be returned. In UTC timezone. |
| `discoveredAtMaxAgeDays` | integer | No | If 0, only return jobs added to our database in the current day. If 1, from today and yesterday, etc. |
| `discoveredAtMinAgeDays` | integer | No | If 1, only return jobs discovered by TheirStack until yesterday. If 2, until 2 days ago, etc. |
| `easyApply` | boolean | No | If True, only return jobs that can be applied directly through the job board. If False, only return jobs that require redirecting to the company's website. |
| `employmentStatusesOr` | string | No | Filter jobs by employment status. Returns jobs that match any of the specified employment types. If no values are provided or an empty list is sent, all jobs regardless of employment status will be returned. |
| `finalUrlExists` | boolean | No | (Use `property_exists_or / property_exists_and` instead) Only return jobs with a final URL. Typically jobs that were originally posted on an ATS. If True, only return jobs with a final URL. If False, only return jobs without a final URL. If None, return all jobs. |
| `fundingStageOr` | string | No | Funding stages of companies returned. Possible values: ['angel', 'convertible_note', 'debt_financing', 'equity_crowdfunding', 'other', 'private_equity', 'seed', 'series_a', 'series_b', 'series_c', 'series_d', 'series_e', 'series_f', 'series_g', 'series_h', 'venture_round_not_specified', 'series_i', 'series_j', 'undisclosed', 'series_unknown', 'pre_seed', 'post_ipo_secondary', 'post_ipo_equity', 'post_ipo_debt', 'non_equity_assistance', 'late_vc', 'initial_coin_offering', 'growth_equity_vc', 'gra |
| `hiringManagersExists` | boolean | No | (Use `property_exists_or / property_exists_and` instead) If True, only return jobs with a hiring manager. If False, only return jobs without a hiring manager. If None, return all jobs. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `includeTotalResults` | boolean | No | When enabled, calculates and returns `total_results` and `total_companies` fields in the response. WARNING: This significantly slows down responses as it requires reading the entire dataset. Recommended usage: enable only for the initial request to get totals, then disable for subsequent pagination requests. |
| `industryIdNot` | string | No | Industry ids to exclude.You can use any of LinkedIn's Industry Codes V2 or GET /v0/catalog/industries |
| `industryIdOr` | string | No | Industry codes. You can use any of LinkedIn's Industry Codes V2 or GET /v0/catalog/industries |
| `industryNot` | string | No | Names of industries, case-insensitive. Results will exclude companies that belong to any of the industries specified in this parameter. Available values: GET /v0/catalog/industries WARNING: Deprecated parameter. Use the industry_id_not field instead. |
| `industryOr` | string | No | Names of industries, case-insensitive. Results will only include companies that belong to any of the industries specified in this parameter. Available values: GET /v0/catalog/industries WARNING: Deprecated parameter. Use the industry_id_or field instead. |
| `jobCountryCodeNot` | string | No | 2-letter ISO country code of the location of the job. Can pass more than 1. Will exclude jobs from these countries |
| `jobCountryCodeOr` | string | No | 2-letter ISO country code of the location of the job. Can pass more than 1 |
| `jobDescriptionContainsNot` | string | No | Exclude jobs whose description contains any of these whole words using word boundaries (\b). Case-insensitive by default, except for the patterns that are uppercase - in that case we'll respect it. Only finds complete words (e.g., searching 'quality' won't match 'inequality'). Results will exclude jobs whose description contains any of these words. |
| `jobDescriptionContainsOr` | string | No | Search for whole words in job descriptions using word boundaries (\b). Case-insensitive by default, except for the patterns that are uppercase - in that case we'll respect it. Only finds complete words (e.g., searching 'quality' won't match 'inequality'). Results will include jobs whose description contains any of these words. |
| `jobDescriptionPatternAnd` | string | No | Regex patterns that must ALL match the job description (AND logic). Use (?i) at the start of a pattern to make it case-insensitive. Results will only include jobs whose description matches every pattern in this list. |
| `jobDescriptionPatternCaseSensitiveOr` | string | No | Deprecated. Use job_description_pattern_or instead, which now behaves identically. |
| `jobDescriptionPatternIsCaseInsensitive` | boolean | No | Deprecated. Has no effect. |
| `jobDescriptionPatternNot` | string | No | Regex patterns to look for in job descriptions. Case-sensitive. Results will include jobs whose description don't match any of these patterns. Use (?i) at the start of a pattern to make it case-insensitive. Can pass more than one. |
| `jobDescriptionPatternOr` | string | No | Regex patterns to look for in job descriptions. Case-sensitive. Results will include jobs whose description matches any of these patterns. Use (?i) at the start of a pattern to make it case-insensitive. Can pass more than one. |
| `jobIdNot` | string | No | Exclude jobs with these IDs. |
| `jobIdOr` | string | No | Get jobs with these IDs only. |
| `jobIds` | string | No | Get jobs with these IDs only. Deprecated parameter, use job_id_or instead. |
| `jobKeywordSlugAnd` | string | No | Will return jobs where all of these keyword slugs appear. Case sensitive. Check out all the keywords we track at GET /v0/catalog/keywords |
| `jobKeywordSlugNot` | string | No | Will return jobs where none of these keyword slugs appear. Case sensitive. Check out all the keywords we track at GET /v0/catalog/keywords |
| `jobKeywordSlugOr` | string | No | Will return jobs where any of these keyword slugs appear. Case sensitive. Check out all the keywords we track at GET /v0/catalog/keywords |
| `jobLocationNot` | string | No | Filter jobs by location. Returns jobs whose locations DO NOT match ANY of the specified location criteria. Each location criteria is specified using a JobLocationFilter object. (You can find location IDs using the locations catalog endpoint) |
| `jobLocationOr` | string | No | Filter jobs by location. Returns jobs whose locations match ANY of the specified location criteria. Each location criteria is specified using a JobLocationFilter object. (You can find location IDs using the locations catalog endpoint) |
| `jobLocationPatternNot` | string | No | Regex patterns to exclude job locations. Case-insensitive. Searches both the location field and the enhanced locations array (using normalized city and state name fields within each location element). Jobs matching ANY of the provided patterns will be EXCLUDED from results. Use this to filter out specific locations. |
| `jobLocationPatternOr` | string | No | Regex patterns to match job locations. Case-insensitive. Searches both the location field and the enhanced locations array (using normalized city and state name fields within each location element). Jobs matching ANY of the provided patterns will be returned. Use this to find jobs in specific cities, states, or regions. |
| `jobSeniorityOr` | string | No | Will return jobs where the seniority is any of the ones passed here |
| `jobTechnologySlugAnd` | string | No | Will return jobs where all of these technologies appear. Case sensitive. Pass slugs. Check out all the technologies we track with the technologies endpoint. |
| `jobTechnologySlugNot` | string | No | Will return jobs where none of these technologies appear. Case sensitive. Pass slugs. Check out all the technologies we track with the technologies endpoint. |
| `jobTechnologySlugOr` | string | No | Will return jobs where any of these technologies appear. Case sensitive. Pass slugs. Check out all the technologies we track with the technologies endpoint. If you pass more than one technology, we will return jobs that mentnion all of the technologies. |
| `jobTitleNot` | string | No | Natural language patterns to match job titles. Case-insensitive. Only jobs with title that do not match any of these patterns will be returned. Uses Postgres full text search. |
| `jobTitleOr` | string | No | Natural language patterns to match job titles. Case-insensitive. Only jobs with title that match any of these patterns will be returned. Uses Postgres full text search. |
| `jobTitlePatternAnd` | string | No | Regex patterns to match job titles. Case-insensitive. Only jobs with title that match all of these patterns will be returned. |
| `jobTitlePatternNot` | string | No | Regex patterns to match job titles. Case-insensitive. Jobs whose job title doesn't match any of the patterns will be returned. |
| `jobTitlePatternOr` | string | No | Regex patterns to match job titles. Case-insensitive. Jobs whose job title matches of the filters will be returned. |
| `lastFundingRoundDateGte` | string | No | Only return companies whose last funding round date is after or on this date. Format: 'YYYY-MM-DD' |
| `lastFundingRoundDateLte` | string | No | Only return companies whose last funding round date is before or on this date. Format: 'YYYY-MM-DD' |
| `limit` | integer | No | Rows to return on this page, up to TheirStack's maximum of 500. Every row returned is billed. |
| `maxEmployeeCount` | integer | No | Maximum number of employees in a company |
| `maxEmployeeCountOrNull` | integer | No | Maximum number of employees in a company. If we don't have company size information, we will return it as well. |
| `maxFundingUsd` | integer | No | Maximum company funding, in USD |
| `maxRevenueUsd` | integer | No | Maximum company revenue, in USD |
| `maxSalaryUsd` | number | No | Maximum annual salary in USD. For example, 150000 means $150,000. |
| `minEmployeeCount` | integer | No | Minimum number of employees in a company |
| `minEmployeeCountOrNull` | integer | No | Minimum number of employees in a company. If we don't have company size information, we will return it as well. |
| `minFundingUsd` | integer | No | Minimum company funding, in USD |
| `minRevenueUsd` | integer | No | Minimum company revenue, in USD |
| `minSalaryUsd` | number | No | Minimum annual salary in USD. For example, 100000 means $100,000. |
| `offset` | integer | No | Number of results to skip. Required for offset-based pagination. |
| `onlyJobsWithHiringManagers` | boolean | No | Only return jobs with a hiring manager. If True, only return jobs with a hiring manager. If False, only return jobs without a hiring manager. If None, return all jobs. |
| `onlyJobsWithReportsTo` | boolean | No | Only return jobs where we identified the role the hired person would report to. Deprecated field, use reports_to_exists instead. |
| `onlyYcCompanies` | boolean | No | Only return YC companies |
| `orderBy` | string | No | List of column objects. You can pass several columns to order by, in order of priority. Only `field` is required, `desc` is True by default. |
| `page` | integer | No | Page number. Required when using page-based pagination. |
| `postedAtGte` | string | No | ISO 8601 date string (yyyy-mm-dd). Only jobs published in this date or after will be returned. |
| `postedAtLte` | string | No | ISO 8601 date string (yyyy-mm-dd). Only jobs published in this date or before will be returned. |
| `postedAtMaxAgeDays` | integer | No | Date posted max age in days. If 0, only return jobs posted today. If 1, from today and yesterday, etc. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `propertyExistsAnd` | string | No |  |
| `propertyExistsOr` | string | No | Return jobs that have any of these fields not null. For example, if you pass ['final_url'], it will return jobs that have a final_url set. This field also support chaining of fields. For example, if you pass ['company_object.domain', 'company_object.linkedin_url'], it will return jobs that have a company domain or a company linkedin_url set. |
| `remote` | boolean | No | True: only show remote jobs. False: only show non-remote jobs. None: show all jobs. |
| `reportsToExists` | boolean | No | Only return jobs where we identified the role the hired person would report to. If True, only return jobs where we identified the role the hired person would report to. If False, only return jobs where we didn't identify the role the hired person would report to. If None, return all jobs. |
| `scraperNamePatternOr` | string | No | Regex patterns to match job sources. Case-insensitive. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `urlDomainNot` | string | No | Exclude jobs if their URL domain (from `url` or `source_url`) is in the provided case-insensitive list. For example, ['greenhouse.io', 'workable.com'] will exclude URLs containing 'greenhouse.io' or 'workable.com'. Refer to our list of sources at https://theirstack.com/en/docs/data/job/sources. |
| `urlDomainOr` | string | No | Include jobs only if their URL domain (from `url` or `source_url`) is in the provided case-insensitive list. For example, ['greenhouse.io', 'workable.com'] will match URLs containing 'greenhouse.io' or 'workable.com'. Refer to our list of sources at https://theirstack.com/en/docs/data/job/sources. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/job_search.theirstack","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","companyCountryCodeNot":"<string>","companyCountryCodeOr":"<string>","companyDescriptionPatternAccentInsensitive":"<boolean>","companyDescriptionPatternNot":"<string>","companyDescriptionPatternOr":"<string>","companyDomainNot":"<string>","companyDomainOr":"<string>","companyIdOr":"<string>","companyInvestorsOr":"<string>","companyInvestorsPartialMatchOr":"<string>","companyKeywordSlugAnd":"<string>","companyKeywordSlugNot":"<string>","companyKeywordSlugOr":"<string>","companyLinkedinUrlExists":"<boolean>","companyLinkedinUrlOr":"<string>","companyListIdNot":"<string>","companyListIdOr":"<string>","companyLocationPatternOr":"<string>","companyNameCaseInsensitiveOr":"<string>","companyNameNot":"<string>","companyNameOr":"<string>","companyNamePartialMatchNot":"<string>","companyNamePartialMatchOr":"<string>","companyTagsOr":"<string>","companyTechnologySlugAnd":"<string>","companyTechnologySlugNot":"<string>","companyTechnologySlugOr":"<string>","companyType":"<string>","discoveredAtGte":"<string>","discoveredAtLte":"<string>","discoveredAtMaxAgeDays":"<integer>","discoveredAtMinAgeDays":"<integer>","easyApply":"<boolean>","employmentStatusesOr":"<string>","finalUrlExists":"<boolean>","fundingStageOr":"<string>","hiringManagersExists":"<boolean>","ignoreSources":"<string>","includeTotalResults":"<boolean>","industryIdNot":"<string>","industryIdOr":"<string>","industryNot":"<string>","industryOr":"<string>","jobCountryCodeNot":"<string>","jobCountryCodeOr":"<string>","jobDescriptionContainsNot":"<string>","jobDescriptionContainsOr":"<string>","jobDescriptionPatternAnd":"<string>","jobDescriptionPatternCaseSensitiveOr":"<string>","jobDescriptionPatternIsCaseInsensitive":"<boolean>","jobDescriptionPatternNot":"<string>","jobDescriptionPatternOr":"<string>","jobIdNot":"<string>","jobIdOr":"<string>","jobIds":"<string>","jobKeywordSlugAnd":"<string>","jobKeywordSlugNot":"<string>","jobKeywordSlugOr":"<string>","jobLocationNot":"<string>","jobLocationOr":"<string>","jobLocationPatternNot":"<string>","jobLocationPatternOr":"<string>","jobSeniorityOr":"<string>","jobTechnologySlugAnd":"<string>","jobTechnologySlugNot":"<string>","jobTechnologySlugOr":"<string>","jobTitleNot":"<string>","jobTitleOr":"<string>","jobTitlePatternAnd":"<string>","jobTitlePatternNot":"<string>","jobTitlePatternOr":"<string>","lastFundingRoundDateGte":"<string>","lastFundingRoundDateLte":"<string>","limit":"<integer>","maxEmployeeCount":"<integer>","maxEmployeeCountOrNull":"<integer>","maxFundingUsd":"<integer>","maxRevenueUsd":"<integer>","maxSalaryUsd":"<number>","minEmployeeCount":"<integer>","minEmployeeCountOrNull":"<integer>","minFundingUsd":"<integer>","minRevenueUsd":"<integer>","minSalaryUsd":"<number>","offset":"<integer>","onlyJobsWithHiringManagers":"<boolean>","onlyJobsWithReportsTo":"<boolean>","onlyYcCompanies":"<boolean>","orderBy":"<string>","page":"<integer>","postedAtGte":"<string>","postedAtLte":"<string>","postedAtMaxAgeDays":"<integer>","preferLatencyUnderMs":"<integer>","propertyExistsAnd":"<string>","propertyExistsOr":"<string>","remote":"<boolean>","reportsToExists":"<boolean>","scraperNamePatternOr":"<string>","source":"<string>","urlDomainNot":"<string>","urlDomainOr":"<string>"}}'
```

### Levels.fyi Jobs

Search Levels.fyi job listings by title or keyword and get each job with its salary range and estimated total compensation where Levels.fyi has them, plus company, location, posting date and apply link. Returns up to 20 jobs per call, grouped by company; filter by location and sort by relevance, date or pay.

**Price:** \$0.85 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Levels.fyi Jobs pricing and uptime](https://getanyapi.com/api/levels/jobs) - live USD price, lane routing, and measured 30-day uptime. [Every Levels endpoint](https://getanyapi.com/api/levels).

`POST /v1/run/levels.jobs`

**Cost:** Up to $0.000927 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.000927 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/6aeb5699-b83f-4a26-868a-1d28483fe6e8

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum number of jobs to return (1-20, default 20). Levels.fyi groups jobs by company, up to 3 per company, so several results can come from one employer. |
| `location` | string | No | Levels.fyi location slug as it appears in Levels.fyi URLs, e.g. united-states. Not a free-text city name; omit it to search everywhere. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Job title, keywords or company name to search, e.g. software engineer or google. |
| `sortBy` | string | No | Sort order: best match (relevance), most recently posted (date), or highest total compensation (compensation). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/levels.jobs","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","limit":"<integer>","location":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","sortBy":"<string>","source":"<string>"}}'
```

### LinkedIn Ad Details

Look up a single LinkedIn Ad Library ad by URL and get the advertiser, headline, creative text, format, CTA, targeting, run dates, and impressions as clean JSON.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [LinkedIn Ad Details pricing and uptime](https://getanyapi.com/api/linkedin/ad) - live USD price, lane routing, and measured 30-day uptime. [Every Linkedin endpoint](https://getanyapi.com/api/linkedin).

`POST /v1/run/linkedin.ad`

**Cost:** Up to $0.002758 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.002758 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/fd687489-00a5-4cf7-b19b-c7e1c4bfca2a

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | LinkedIn Ad Library ad URL (e.g. "https://www.linkedin.com/ad-library/detail/666281156"). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/linkedin.ad","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### LinkedIn Ads Library

Search the LinkedIn Ad Library by search URL and list the matching ads (advertiser, creative text, format).

**Price:** billed per result - \$0.06 per 1,000 requests base + \$1.65 per 1,000 results, capped at \$33.10 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [LinkedIn Ads Library pricing and uptime](https://getanyapi.com/api/linkedin/ads) - live USD price, lane routing, and measured 30-day uptime. [Every Linkedin endpoint](https://getanyapi.com/api/linkedin).

`POST /v1/run/linkedin.ads`

**Cost:** Up to $0.013407 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.013407 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/907266b4-1118-4d11-b036-41d263de1dc1

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum number of results to return (1-20, default 20). You are billed per result returned, so a lower limit costs less. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | LinkedIn Ad Library search URL or a LinkedIn company URL (e.g. https://www.linkedin.com/ad-library/search?companyIds=1035). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/linkedin.ads","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","limit":"<integer>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### LinkedIn Ad Search

Search the LinkedIn Ad Library by company or keyword and list matching ads (advertiser, headline, creative text, format, CTA, and run dates) with pagination.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [LinkedIn Ad Search pricing and uptime](https://getanyapi.com/api/linkedin/ads-search) - live USD price, lane routing, and measured 30-day uptime. [Every Linkedin endpoint](https://getanyapi.com/api/linkedin).

`POST /v1/run/linkedin.ads_search`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/627907a2-6fb3-4537-bacd-685b077c0419

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `company` | string | No | Company name to search (e.g. "microsoft"). |
| `companyId` | string | No | LinkedIn company identifier. |
| `countries` | string | No | Comma-separated two-letter country codes (e.g. "US,CA,MX"). |
| `cursor` | string | No | Opaque pagination cursor from a previous response's `nextCursor`; omit for the first page. |
| `endDate` | string | No | Search end date in YYYY-MM-DD format. Today or a later date is moved back to yesterday in UTC when your range overlaps LinkedIn's accepted dates. When you send startDate without endDate, the search ends yesterday in UTC, the latest day LinkedIn accepts. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `keyword` | string | No | Keyword term for the ad search. |
| `paginationToken` | string | No | Legacy pagination alias. Prefer `cursor`; omit both fields for the first page. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `startDate` | string | No | Search start date in YYYY-MM-DD format. An earlier date is moved up to one year ago in UTC when your range overlaps LinkedIn's accepted dates. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/linkedin.ads_search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","company":"<string>","companyId":"<string>","countries":"<string>","cursor":"<string>","endDate":"<string>","ignoreSources":"<string>","keyword":"<string>","paginationToken":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","startDate":"<string>"}}'
```

### LinkedIn Comment Reactions

List who reacted to a comment on a LinkedIn post - reactor name, profile URL, job title, and reaction type, 100 per page.

**Price:** \$2.60 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [LinkedIn Comment Reactions pricing and uptime](https://getanyapi.com/api/linkedin/comment-reactions) - live USD price, lane routing, and measured 30-day uptime. [Every Linkedin endpoint](https://getanyapi.com/api/linkedin).

`POST /v1/run/linkedin.comment_reactions`

**Cost:** Up to $0.002834 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.002834 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/5d2610ca-4e71-45b0-8431-fc9ffdc61b44

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `page` | integer | No | Which page of up to 100 reactions to return, starting at 1 (default 1). Each page is billed as one request; totalPages in the response says how many there are. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | LinkedIn comment URL, as returned in the url field of linkedin.post_comments or copied with "Copy link to comment" (a /feed/update/... link carrying commentUrn and dashCommentUrn). A post URL without dashCommentUrn, or a reply's URL (carrying replyUrn), is refused as invalid input, with no charge. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/linkedin.comment_reactions","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","page":"<integer>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### LinkedIn Comment Replies

List up to the 10 newest replies to a comment on a LinkedIn post - reply text, replier name/URL/job title, timestamps, and likes.

**Price:** \$2.60 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [LinkedIn Comment Replies pricing and uptime](https://getanyapi.com/api/linkedin/comment-replies) - live USD price, lane routing, and measured 30-day uptime. [Every Linkedin endpoint](https://getanyapi.com/api/linkedin).

`POST /v1/run/linkedin.comment_replies`

**Cost:** Up to $0.002834 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.002834 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/2e45e51d-9b04-4602-accd-e53f9bd084e3

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | LinkedIn comment URL, as returned in the url field of linkedin.post_comments or copied with "Copy link to comment" (a /feed/update/... link carrying commentUrn and dashCommentUrn). A reply's URL returns the thread it belongs to. A post URL without dashCommentUrn is refused as invalid input, with no charge. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/linkedin.comment_replies","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### LinkedIn Company

Fetch a full LinkedIn company page by URL: name, description, industry, employee count and range, follower count, founded year, headquarters and office locations, funding data, tagline, logo, website, and specialities.

**Price:** \$1.10 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 5 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [LinkedIn Company pricing and uptime](https://getanyapi.com/api/linkedin/company) - live USD price, lane routing, and measured 30-day uptime. [Every Linkedin endpoint](https://getanyapi.com/api/linkedin).

`POST /v1/run/linkedin.company`

**Cost:** Up to $0.002758 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.002758 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/b95e98b6-e9b1-4de3-9562-91f7a4cc6789

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `city` or `postalCode`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Full LinkedIn company page URL. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/linkedin.company","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>","url":"<string>"}}'
```

### LinkedIn Company Employees

List the employees of a LinkedIn company by name or company URL, with optional job-title filtering.

**Price:** billed per result - \$3.20 per 1,000 requests base + \$4.80 per 1,000 results, capped at \$51.20 per 1,000 requests.

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [LinkedIn Company Employees pricing and uptime](https://getanyapi.com/api/linkedin/company-employees) - live USD price, lane routing, and measured 30-day uptime. [Every Linkedin endpoint](https://getanyapi.com/api/linkedin).

`POST /v1/run/linkedin.company_employees`

**Cost:** Up to $0.1199 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.1199 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/bbe38c92-3c58-4b03-a180-eff164c2e0df

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `company` | string | Yes | Company name or LinkedIn company URL (e.g. google or https://www.linkedin.com/company/google/). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `jobTitle` | string | No | Optional job-title filter supporting boolean operators (e.g. CEO OR CTO). |
| `limit` | integer | No | Maximum number of results to return (1-10, default 10). |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `openToWork` or `premium`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be abs |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/linkedin.company_employees","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","company":"<string>","ignoreSources":"<string>","jobTitle":"<string>","limit":"<integer>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>"}}'
```

### RedNote (Xiaohongshu) Note Comments

List comments on a RedNote (Xiaohongshu) note and return normalized comment records with pagination.

**Price:** \$12.00 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [RedNote (Xiaohongshu) Note Comments pricing and uptime](https://getanyapi.com/api/rednote/note-comments) - live USD price, lane routing, and measured 30-day uptime. [Every Rednote endpoint](https://getanyapi.com/api/rednote).

`POST /v1/run/rednote.note_comments`

**Cost:** Up to $0.01308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.01308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/9f26408b-d212-4a66-a8f9-be742c20ef88

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Pagination cursor from the previous response. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `noteId` | string | Yes | RedNote (Xiaohongshu) note ID. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/rednote.note_comments","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","ignoreSources":"<string>","noteId":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### LinkedIn Company Posts

List a LinkedIn company page's recent posts by URL: full text, canonical link, publish date, author, engagement counts with a per-reaction breakdown, and attached media.

**Price:** \$2.90 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [LinkedIn Company Posts pricing and uptime](https://getanyapi.com/api/linkedin/company-posts) - live USD price, lane routing, and measured 30-day uptime. [Every Linkedin endpoint](https://getanyapi.com/api/linkedin).

`POST /v1/run/linkedin.company_posts`

**Cost:** Up to $0.106275 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.106275 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/b51e168a-4253-4fa6-98df-2331b9c554c8

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `includeQuotePosts` | boolean | No | Include quote posts (posts shared with an added comment). Defaults to true; set false to exclude them. |
| `includeReposts` | boolean | No | Include reposts (posts shared without an added comment). Defaults to true; set false to exclude them. |
| `limit` | integer | No | Maximum number of posts to return. |
| `postedLimit` | string | No | Only return posts published within this window (default any). |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Full LinkedIn company page URL. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/linkedin.company_posts","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","includeQuotePosts":"<boolean>","includeReposts":"<boolean>","limit":"<integer>","postedLimit":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### LinkedIn Company Posts (basic)

Post text and link only. No engagement counts, author details, media, or reaction breakdown - for those use linkedin.company_posts.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [LinkedIn Company Posts (basic) pricing and uptime](https://getanyapi.com/api/linkedin/company-posts-thin) - live USD price, lane routing, and measured 30-day uptime. [Every Linkedin endpoint](https://getanyapi.com/api/linkedin).

`POST /v1/run/linkedin.company_posts_thin`

**Cost:** Up to $0.002638 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.002638 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/83f21e2b-0e94-4ffd-87b3-43ee177c03ef

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `page` | integer | No | Page number for pagination. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Full LinkedIn company page URL. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/linkedin.company_posts_thin","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","page":"<integer>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### LinkedIn Company (basic)

Basic company: name, description, employee count, industry, logo, website, tagline. No follower count, founded year, office locations, or funding data - for those use linkedin.company.

**Price:** \$1.00 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 4 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [LinkedIn Company (basic) pricing and uptime](https://getanyapi.com/api/linkedin/company-thin) - live USD price, lane routing, and measured 30-day uptime. [Every Linkedin endpoint](https://getanyapi.com/api/linkedin).

`POST /v1/run/linkedin.company_thin`

**Cost:** Up to $0.002758 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.002758 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/feb20306-9646-4232-a54d-faa93f561d32

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `companyType` or `coverImage`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Full LinkedIn company page URL. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/linkedin.company_thin","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>","url":"<string>"}}'
```

### LinkedIn Group

Fetch one LinkedIn group by URL or id: name, description, rules, member count, logo and cover image, creation date, visibility and join settings, and its admins.

**Price:** \$1.30 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [LinkedIn Group pricing and uptime](https://getanyapi.com/api/linkedin/group) - live USD price, lane routing, and measured 30-day uptime. [Every Linkedin endpoint](https://getanyapi.com/api/linkedin).

`POST /v1/run/linkedin.group`

**Cost:** Up to $0.001417 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001417 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/cd9c720b-e94a-40bd-a4f1-21f10b679784

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `groupId` | string | No | Numeric LinkedIn group id (e.g. 1898033), the number in the group URL. Send this or url. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | No | LinkedIn group URL (e.g. https://www.linkedin.com/groups/1898033). Send this or groupId. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/linkedin.group","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","groupId":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### LinkedIn Group Posts

List the posts in a LinkedIn group by group URL, newest first: full text, canonical link, publish date, author, engagement counts with a per-reaction breakdown, and attached media. One call returns a page of about 100 posts; pass page to go further back.

**Price:** \$2.60 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [LinkedIn Group Posts pricing and uptime](https://getanyapi.com/api/linkedin/group-posts) - live USD price, lane routing, and measured 30-day uptime. [Every Linkedin endpoint](https://getanyapi.com/api/linkedin).

`POST /v1/run/linkedin.group_posts`

**Cost:** Up to $0.002834 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.002834 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/65eec61b-b817-4250-a472-c8ca60356c17

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `page` | integer | No | Which page of about 100 posts to return, starting at 1 (default 1). Page 2 continues where page 1 ended, going further back in time. Each page is billed as one request. |
| `postedLimit` | string | No | Only return posts published within this window (default any). The window is applied to the page, so a page can come back with fewer posts or none. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Full LinkedIn group URL (e.g. https://www.linkedin.com/groups/1898033). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/linkedin.group_posts","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","page":"<integer>","postedLimit":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### LinkedIn Job

Fetch one LinkedIn job posting by URL: title, full description, location, salary when disclosed, applicant count, employment and workplace type, seniority, benefits, industries, apply links, posting and expiry dates, the hiring team, the applicant tracking system behind it, and the hiring company with its size, follower count, website and description.

**Price:** \$1.50 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [LinkedIn Job pricing and uptime](https://getanyapi.com/api/linkedin/job) - live USD price, lane routing, and measured 30-day uptime. [Every Linkedin endpoint](https://getanyapi.com/api/linkedin).

`POST /v1/run/linkedin.job`

**Cost:** Up to $0.001635 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001635 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/2ccc99c2-59af-4338-b62c-583c466e9d72

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Full LinkedIn job posting URL, e.g. https://www.linkedin.com/jobs/view/4431721875/. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/linkedin.job","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### LinkedIn Jobs

Search LinkedIn job listings by title and location - full records with description, salary, applicant count, seniority, company details, and benefits. Up to 25 jobs per request.

**Price:** \$19.50 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [LinkedIn Jobs pricing and uptime](https://getanyapi.com/api/linkedin/jobs) - live USD price, lane routing, and measured 30-day uptime. [Every Linkedin endpoint](https://getanyapi.com/api/linkedin).

`POST /v1/run/linkedin.jobs`

**Cost:** Up to $0.031174 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.031174 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/a0eb53ca-bc2a-4746-b405-48e2f6565e6c

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `company` | string | No | Filter to a specific company by name (e.g. Google). |
| `cursor` | string | No | Opaque pagination cursor from a previous response's nextCursor. Omit for the first page; pass it to fetch the next page of job listings. |
| `easyApply` | boolean | No | When true, only return jobs offering LinkedIn Easy Apply. |
| `employmentType` | string | No | Filter by employment type. |
| `experienceLevel` | string | No | Filter by required seniority/experience level. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Accepted for compatibility and ignored: each call returns one full page of up to 25 jobs at one flat price per call; follow nextCursor for more. |
| `location` | string | No | City, region, or country to search within (e.g. United States, San Francisco). |
| `postedLimit` | string | No | Only jobs posted within this window (past hour, 24 hours, week, or month). |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Job title or keywords to search. Supports LinkedIn boolean operators. |
| `salary` | string | No | Filter by minimum base salary band (US dollars). |
| `sortBy` | string | No | Sort order: most recent (date) or best match (relevance). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `under10Applicants` | boolean | No | When true, only return jobs with fewer than 10 applicants (lower competition). |
| `workplaceType` | string | No | Filter by workplace type (remote, hybrid, or onsite). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/linkedin.jobs","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","company":"<string>","cursor":"<string>","easyApply":"<boolean>","employmentType":"<string>","experienceLevel":"<string>","ignoreSources":"<string>","limit":"<integer>","location":"<string>","postedLimit":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","salary":"<string>","sortBy":"<string>","source":"<string>","under10Applicants":"<boolean>","workplaceType":"<string>"}}'
```

### LinkedIn Jobs (index)

Cheap job index: title, company, location, posted date, URL. No description, salary, applicant counts, or seniority - for those use linkedin.jobs.

**Price:** \$0.66 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [LinkedIn Jobs (index) pricing and uptime](https://getanyapi.com/api/linkedin/jobs-thin) - live USD price, lane routing, and measured 30-day uptime. [Every Linkedin endpoint](https://getanyapi.com/api/linkedin).

`POST /v1/run/linkedin.jobs_thin`

**Cost:** Up to $0.000872 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.000872 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/f02bf63d-3db1-40c4-906d-7c1db4bc18f0

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `companyId` | string | No | Filter to a specific company by its LinkedIn numeric company id. |
| `cursor` | string | No | Opaque pagination cursor from a previous response's nextCursor. Omit for the first page; pass it to fetch the next page of job listings. |
| `employmentType` | string | No | Filter by employment type. |
| `experienceLevel` | string | No | Filter by required seniority/experience level. |
| `geoId` | string | No | LinkedIn geo id to target a precise location (e.g. 103644278 for the United States); more exact than the free-text location. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Accepted for compatibility and ignored: each call returns one full source page (10 or 25 jobs depending on source); follow nextCursor for more. |
| `location` | string | No | City, region, or country to search within. |
| `postedLimit` | string | No | Only jobs posted within this window (past 24 hours, week, or month). |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Job title or keywords to search. |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `logoUrl`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a listing |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `workplaceType` | string | No | Filter by workplace type (remote, hybrid, or onsite). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/linkedin.jobs_thin","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","companyId":"<string>","cursor":"<string>","employmentType":"<string>","experienceLevel":"<string>","geoId":"<string>","ignoreSources":"<string>","limit":"<integer>","location":"<string>","postedLimit":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","requireFields":"<string>","source":"<string>","workplaceType":"<string>"}}'
```

### LinkedIn Post

Fetch a single LinkedIn post or article by URL (title, text, author, like and comment counts, publish date).

**Price:** \$0.80 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 4 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [LinkedIn Post pricing and uptime](https://getanyapi.com/api/linkedin/post) - live USD price, lane routing, and measured 30-day uptime. [Every Linkedin endpoint](https://getanyapi.com/api/linkedin).

`POST /v1/run/linkedin.post`

**Cost:** Up to $0.002758 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.002758 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/9d2ec8dc-bcbb-4d3b-94c5-bb577b865bbf

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `image`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a post that |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Full LinkedIn post or article URL. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/linkedin.post","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>","url":"<string>"}}'
```

### LinkedIn Post Comments

List comments on a LinkedIn post - full text, commenter name/URL/job title, timestamps, and engagement.

**Price:** \$2.90 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 4 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [LinkedIn Post Comments pricing and uptime](https://getanyapi.com/api/linkedin/post-comments) - live USD price, lane routing, and measured 30-day uptime. [Every Linkedin endpoint](https://getanyapi.com/api/linkedin).

`POST /v1/run/linkedin.post_comments`

**Cost:** Up to $0.2398 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.2398 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/98dae97e-118d-4533-a990-e37546ecea7f

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum number of comments to return. |
| `postedLimit` | string | No | Only return comments posted within this window (default any). |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Full URL of the LinkedIn post to list comments for. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/linkedin.post_comments","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","limit":"<integer>","postedLimit":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### LinkedIn Post Reactions

List who reacted to a LinkedIn post - reactor name, profile URL, job title, and reaction type. Lead-gen grade.

**Price:** \$2.90 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [LinkedIn Post Reactions pricing and uptime](https://getanyapi.com/api/linkedin/post-reactions) - live USD price, lane routing, and measured 30-day uptime. [Every Linkedin endpoint](https://getanyapi.com/api/linkedin).

`POST /v1/run/linkedin.post_reactions`

**Cost:** Up to $0.2398 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.2398 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/91afeaa8-4931-48c1-a313-100303cac39f

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum number of reactions to return (1-100, default 100). |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `postId`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. Naming a combination that no single source retu |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | URL of the LinkedIn post to list reactions for (a /posts/...-activity-... or /feed/update/urn:li:activity:... link). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/linkedin.post_reactions","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","limit":"<integer>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>","url":"<string>"}}'
```

### LinkedIn Post Transcript

Get the spoken transcript of a LinkedIn video post by URL.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [LinkedIn Post Transcript pricing and uptime](https://getanyapi.com/api/linkedin/post-transcript) - live USD price, lane routing, and measured 30-day uptime. [Every Linkedin endpoint](https://getanyapi.com/api/linkedin).

`POST /v1/run/linkedin.post_transcript`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/cf239605-3eea-4a17-96ec-6c6a62b0d200

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | The full URL of the LinkedIn post to get the video transcript from. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/linkedin.post_transcript","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### LinkedIn Profile

Fetch a rich LinkedIn member profile by URL: name, headline, avatar, location, connections and followers, current position, and full work experience with job titles, descriptions, dates, employment/workplace type, and per-role skills, plus education, skills, certifications, honors and awards, languages, projects, publications, and verified/premium/open-to-work flags.

**Price:** \$2.90 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [LinkedIn Profile pricing and uptime](https://getanyapi.com/api/linkedin/profile) - live USD price, lane routing, and measured 30-day uptime. [Every Linkedin endpoint](https://getanyapi.com/api/linkedin).

`POST /v1/run/linkedin.profile`

**Cost:** Up to $0.004578 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.004578 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/9041dbf4-6d6b-4ba9-a42b-cd72821528db

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `topSkills` or `workplaceType`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Full LinkedIn profile URL. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/linkedin.profile","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>","url":"<string>"}}'
```

### LinkedIn Profile Comments

List the comments a LinkedIn member has left on other people's posts - the comment text, its permalink and timestamp, plus the post it was left on and that post's author and engagement.

**Price:** \$2.90 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [LinkedIn Profile Comments pricing and uptime](https://getanyapi.com/api/linkedin/profile-comments) - live USD price, lane routing, and measured 30-day uptime. [Every Linkedin endpoint](https://getanyapi.com/api/linkedin).

`POST /v1/run/linkedin.profile_comments`

**Cost:** Up to $0.004207 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.004207 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/96cd8d97-6264-49ea-9344-5da427249a6b

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum number of comments to return. |
| `postedLimit` | string | No | Only return comments posted within this window (default any). |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `edited` or `isAuthor`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Full URL of the LinkedIn member profile whose comments on other people's posts should be listed. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/linkedin.profile_comments","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","limit":"<integer>","postedLimit":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>","url":"<string>"}}'
```

### LinkedIn Profile Posts (full)

Fetch recent public LinkedIn profile posts with enriched author, engagement, article, newsletter, media, annotation, repost, and social activity details.

**Price:** \$5.00 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [LinkedIn Profile Posts (full) pricing and uptime](https://getanyapi.com/api/linkedin/profile-posts-full) - live USD price, lane routing, and measured 30-day uptime. [Every Linkedin endpoint](https://getanyapi.com/api/linkedin).

`POST /v1/run/linkedin.profile_posts_full`

**Cost:** Up to $0.21146 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.21146 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/f6850243-72d7-4a6d-9d49-7419e910e431

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `contextCountry` | string | No | Regional LinkedIn context used when retrieving posts. |
| `cursor` | string | No | Pagination cursor from a previous response's nextCursor. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `includeQuotePosts` | boolean | No | Whether to include quote posts that add commentary to shared content. |
| `includeReposts` | boolean | No | Whether to include reposts that share content without added commentary. |
| `limit` | integer | No | Most posts to return (1-100, default 10). Ignored on sources that page: each call returns one full page of 50 posts; follow nextCursor for more. Sources that cannot page return up to `limit` posts in one call with no nextCursor. |
| `postedLimit` | string | No | Only return posts published within this relative time window. |
| `postedLimitDate` | string | No | Only return posts published on or after this date or timestamp, using a JavaScript-compatible date-time string. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `nextCursor`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a prof |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Full URL of the public LinkedIn profile whose posts should be returned. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/linkedin.profile_posts_full","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","contextCountry":"<string>","cursor":"<string>","ignoreSources":"<string>","includeQuotePosts":"<boolean>","includeReposts":"<boolean>","limit":"<integer>","postedLimit":"<string>","postedLimitDate":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>","url":"<string>"}}'
```

### LinkedIn Profile Posts (basic)

Fetch recent public LinkedIn profile posts with portable identity, author, engagement, article, image, video, and repost fields.

**Price:** \$5.00 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 4 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [LinkedIn Profile Posts (basic) pricing and uptime](https://getanyapi.com/api/linkedin/profile-posts-thin) - live USD price, lane routing, and measured 30-day uptime. [Every Linkedin endpoint](https://getanyapi.com/api/linkedin).

`POST /v1/run/linkedin.profile_posts_thin`

**Cost:** Up to $0.21146 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.21146 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/b9b81320-77cd-4856-8294-c58996dd70cb

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Pagination cursor from a previous response's nextCursor. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Most posts to return (10-100, default 10). Ignored on sources that page: each call returns one full page of 50 posts; follow nextCursor for more. Sources that cannot page return up to `limit` posts in one call with no nextCursor. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `nextCursor`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a prof |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Full URL of the public LinkedIn profile whose posts should be returned. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/linkedin.profile_posts_thin","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","ignoreSources":"<string>","limit":"<integer>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>","url":"<string>"}}'
```

### LinkedIn Profile Reactions

List the posts a LinkedIn member has reacted to - the reaction, its timestamp, and the full post it was made on with author and engagement.

**Price:** \$2.90 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [LinkedIn Profile Reactions pricing and uptime](https://getanyapi.com/api/linkedin/profile-reactions) - live USD price, lane routing, and measured 30-day uptime. [Every Linkedin endpoint](https://getanyapi.com/api/linkedin).

`POST /v1/run/linkedin.profile_reactions`

**Cost:** Up to $0.004207 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.004207 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/241e94e0-def2-4057-89e8-615b38feedbb

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum number of reactions to return. One upstream page holds 100. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Full URL of the LinkedIn member profile whose reactions to list, for example https://www.linkedin.com/in/williamhgates. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/linkedin.profile_reactions","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","limit":"<integer>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### LinkedIn Profile (basic)

Lightweight profile: name, avatar, location, followers, public id, current company, and a basic experience/education list (company + dates; job titles, the current-role flag and the connections label only where the source and the profile show them; no descriptions or skills; past companies may be redacted). For full experience detail, skills, certifications, and verified flags use linkedin.profile.

**Price:** \$0.80 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [LinkedIn Profile (basic) pricing and uptime](https://getanyapi.com/api/linkedin/profile-thin) - live USD price, lane routing, and measured 30-day uptime. [Every Linkedin endpoint](https://getanyapi.com/api/linkedin).

`POST /v1/run/linkedin.profile_thin`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/3feb9ada-a3af-41c6-8dd7-e76325007dfc

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `headline` or `recentPosts`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be a |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Full LinkedIn person profile URL, carrying the profile id after /in/, for example https://www.linkedin.com/in/williamhgates. Any other LinkedIn URL names no person, so it is rejected instead of charged: send a company page to linkedin.company_thin or linkedin.company, and a post to linkedin.post. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/linkedin.profile_thin","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>","url":"<string>"}}'
```

### LinkedIn Company Search

Search LinkedIn companies by keyword with optional location filtering, returning normalized company records.

**Price:** \$5.00 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [LinkedIn Company Search pricing and uptime](https://getanyapi.com/api/linkedin/search-companies) - live USD price, lane routing, and measured 30-day uptime. [Every Linkedin endpoint](https://getanyapi.com/api/linkedin).

`POST /v1/run/linkedin.search_companies`

**Cost:** Up to $0.024634 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.024634 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/732bcdff-a737-4f3a-81a8-1cb85bbc1df1

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum number of results to return (1-20, default 20). |
| `location` | string | No | Optional location filter, written out in full (e.g. United Kingdom or San Francisco). |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Keyword to search LinkedIn companies for (e.g. marketing agency). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/linkedin.search_companies","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","limit":"<integer>","location":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","source":"<string>"}}'
```

### LinkedIn Group Search

Search LinkedIn groups by keyword, 10 per page: group name, URL, member count, summary, and logo.

**Price:** \$1.30 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [LinkedIn Group Search pricing and uptime](https://getanyapi.com/api/linkedin/search-groups) - live USD price, lane routing, and measured 30-day uptime. [Every Linkedin endpoint](https://getanyapi.com/api/linkedin).

`POST /v1/run/linkedin.search_groups`

**Cost:** Up to $0.001417 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001417 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/b7a894ea-e609-451b-a372-eb5a026802cd

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `page` | integer | No | Which page of up to 10 groups to return, starting at 1 (1-100, default 1). Each page is billed as one request. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Keyword to search LinkedIn groups for (e.g. python or sales). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/linkedin.search_groups","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","page":"<integer>","preferLatencyUnderMs":"<integer>","query":"<string>","source":"<string>"}}'
```

### LinkedIn Sales Navigator Lead Search

LinkedIn lead search with Sales Navigator's search and filters: one call returns a page of up to 25 people matching a keyword and Sales Navigator lead filters (location, job title, current and past company, school, seniority, function, company size, and more), or the results of a Sales Navigator lead-search URL you built yourself. Each lead comes with name, current positions, location, summary, and photo, and its url opens the profile and can be passed to linkedin.profile for the full record. For full profiles in one call use linkedin.search_profiles.

**Price:** \$70.00 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [LinkedIn Sales Navigator Lead Search pricing and uptime](https://getanyapi.com/api/linkedin/search-leads) - live USD price, lane routing, and measured 30-day uptime. [

`POST /v1/run/linkedin.search_leads`

**Cost:** Up to $0.0763 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.0763 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/2025b66f-d303-42de-be57-a9371238534d

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `companyHeadcount` | string | No | Filter by current company size (employee count). Codes: A=Self-Employed, B=1-10, C=11-50, D=51-200, E=201-500, F=501-1,000, G=1,001-5,000, H=5,001-10,000, I=10,001+. |
| `companyHeadquarterLocations` | string | No | Filter by the location of the person's current company headquarters, by place name (e.g. ['United States']). Commas are not allowed in a value. Up to 70 values. |
| `currentCompanies` | string | No | Filter to people who currently work at any of these companies, by name (e.g. ['Google','Meta']). Multiple names widen the match (OR). Commas are not allowed in a value. Up to 50 values. |
| `excludeCompanyHeadquarterLocations` | string | No | Exclude people whose current company is headquartered in any of these locations. Commas are not allowed in a value. Up to 70 values. |
| `excludeCurrentCompanies` | string | No | Exclude people who currently work at any of these companies, by name. Commas are not allowed in a value. Up to 50 values. |
| `excludeCurrentJobTitles` | string | No | Exclude people whose current job title matches any of these. Commas are not allowed in a value. Up to 70 values. |
| `excludeFunctionIds` | string | No | Exclude these job functions (same codes as functionIds). Up to 30 values. |
| `excludeLocations` | string | No | Exclude people in any of these locations, by place name. Commas are not allowed in a value. Up to 70 values. |
| `excludePastCompanies` | string | No | Exclude people who previously worked at any of these companies, by name. Commas are not allowed in a value. Up to 50 values. |
| `excludePastJobTitles` | string | No | Exclude people who held any of these past job titles. Commas are not allowed in a value. Up to 70 values. |
| `excludeSchools` | string | No | Exclude people who attended any of these schools, by name. Commas are not allowed in a value. Up to 50 values. |
| `excludeSeniorityLevelIds` | string | No | Exclude these seniority levels (same codes as seniorityLevelIds). Up to 20 values. |
| `firstNames` | string | No | Filter to people whose first name matches any of these. Commas are not allowed in a value. Up to 70 values. |
| `functionIds` | string | No | Filter by job function. Codes: 1=Accounting, 2=Administrative, 3=Arts and Design, 4=Business Development, 5=Community and Social Services, 6=Consulting, 7=Education, 8=Engineering, 9=Entrepreneurship, 10=Finance, 11=Healthcare Services, 12=Human Resources, 13=Information Technology, 14=Legal, 15=Marketing, 16=Media and Communication, 17=Military and Protective Services, 18=Operations, 19=Product Management, 20=Program and Project Management, 21=Purchasing, 22=Quality Assurance, 23=Real Estate, 2 |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `jobTitle` | string | No | Optional current job title filter (e.g. 'Software Engineer'). Commas are not allowed in a value. |
| `lastNames` | string | No | Filter to people whose last name matches any of these. Commas are not allowed in a value. Up to 70 values. |
| `location` | string | No | Optional location filter (e.g. 'San Francisco'). Commas are not allowed in a value. |
| `page` | integer | No | Which page of up to 25 leads to return, starting at 1 (1-100, default 1). Also pages through a salesNavUrl search. Each page is billed as one request. |
| `pastCompanies` | string | No | Filter to people who previously worked at any of these companies, by name. Commas are not allowed in a value. Up to 50 values. |
| `pastJobTitles` | string | No | Filter by a past job title the person held (e.g. ['Product Manager']). Commas are not allowed in a value. Up to 70 values. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `profileLanguages` | string | No | Filter by the profile's primary language. |
| `query` | string | No | Search keywords for LinkedIn leads: a role, name, or keywords (e.g. 'Marketing Manager'). Provide this or salesNavUrl. |
| `recentlyChangedJobs` | boolean | No | When true, only return people who recently changed jobs (a strong sales/recruiting signal). |
| `recentlyPostedOnLinkedIn` | boolean | No | When true, only return people who recently posted on LinkedIn (an activity signal). |
| `salesNavUrl` | string | No | Alternatively, a LinkedIn Sales Navigator lead-search URL you built in Sales Navigator (e.g. https://www.linkedin.com/sales/search/people?query=(keywords%3Aengineer)). When set it overrides query and every other filter on this request; only page still applies. |
| `schools` | string | No | Filter to people who attended any of these schools, by name. Commas are not allowed in a value. Up to 50 values. |
| `seniorityLevelIds` | string | No | Filter by seniority level. Codes: 100=In Training, 110=Entry Level, 120=Senior, 130=Strategic, 200=Entry Level Manager, 210=Experienced Manager, 220=Director, 300=Vice President, 310=CXO, 320=Owner/Partner. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `yearsAtCurrentCompanyIds` | string | No | Filter by tenure at the current company. Codes: 1=Less than 1 year, 2=1 to 2 years, 3=3 to 5 years, 4=6 to 10 years, 5=More than 10 years. |
| `yearsOfExperienceIds` | string | No | Filter by total years of experience. Codes: 1=Less than 1 year, 2=1 to 2 years, 3=3 to 5 years, 4=6 to 10 years, 5=More than 10 years. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/linkedin.search_leads","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","companyHeadcount":"<string>","companyHeadquarterLocations":"<string>","currentCompanies":"<string>","excludeCompanyHeadquarterLocations":"<string>","excludeCurrentCompanies":"<string>","excludeCurrentJobTitles":"<string>","excludeFunctionIds":"<string>","excludeLocations":"<string>","excludePastCompanies":"<string>","excludePastJobTitles":"<string>","excludeSchools":"<string>","excludeSeniorityLevelIds":"<string>","firstNames":"<string>","functionIds":"<string>","ignoreSources":"<string>","jobTitle":"<string>","lastNames":"<string>","location":"<string>","page":"<integer>","pastCompanies":"<string>","pastJobTitles":"<string>","preferLatencyUnderMs":"<integer>","profileLanguages":"<string>","query":"<string>","recentlyChangedJobs":"<boolean>","recentlyPostedOnLinkedIn":"<boolean>","salesNavUrl":"<string>","schools":"<string>","seniorityLevelIds":"<string>","source":"<string>","yearsAtCurrentCompanyIds":"<string>","yearsOfExperienceIds":"<string>"}}'
```

### LinkedIn Post Search

Search public LinkedIn posts by keyword (text, link, publish date). Results come from search-engine matches over public LinkedIn posts and work best with English keywords.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [LinkedIn Post Search pricing and uptime](https://getanyapi.com/api/linkedin/search-posts) - live USD price, lane routing, and measured 30-day uptime. [Every Linkedin endpoint](https://getanyapi.com/api/linkedin).

`POST /v1/run/linkedin.search_posts`

**Cost:** Up to $0.01744 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.01744 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/a51df0e8-fc6a-4e83-9163-56869e6adac8

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Pagination cursor from a previous response. |
| `datePosted` | string | No | Filter by recency. One of last-hour, last-day, last-week, last-month, last-year. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | The post search query. |
| `requireCursor` | boolean | No | Deprecated. Every source for this search returns a nextCursor, so this changes nothing about the price or which source serves you; it stays accepted so callers that already send it keep working. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/linkedin.search_posts","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","datePosted":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","requireCursor":"<boolean>","source":"<string>"}}'
```

### LinkedIn Post Search (full)

Search public LinkedIn posts with rich author, engagement, attachment, and poll details.

**Price:** \$4.00 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 4 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [LinkedIn Post Search (full) pricing and uptime](https://getanyapi.com/api/linkedin/search-posts-full) - live USD price, lane routing, and measured 30-day uptime. [Every Linkedin endpoint](https://getanyapi.com/api/linkedin).

`POST /v1/run/linkedin.search_posts_full`

**Cost:** Up to $0.21146 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.21146 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/7c25925b-662e-478c-91e4-e87b9be432b0

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `authorCompanyNames` | string | No | Only return posts by people associated with these company names. |
| `authorIndustryIds` | string | No | Only return posts by authors associated with these LinkedIn industry IDs. |
| `authorKeywords` | string | No | Only return posts whose author profile headline or job title contains at least one of these keywords. |
| `authorUrls` | string | No | Only return posts authored by these LinkedIn profile or company URLs. |
| `contentType` | string | No | Only return posts carrying this content type. |
| `datePosted` | string | No | Only return posts published within this relative time window. Last-hour and windows beyond one month route to the provider that supports them. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum number of posts to return (1-100, default 10). The upper bound is one LinkedIn search page. |
| `mentioningMemberUrls` | string | No | Only return posts mentioning these LinkedIn member profile URLs. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | LinkedIn post search query, including quoted terms or Boolean operators accepted by LinkedIn search. |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `attachmentType` or `pollOptions`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can stil |
| `sort` | string | No | Order results by search relevance or publication date. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/linkedin.search_posts_full","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","authorCompanyNames":"<string>","authorIndustryIds":"<string>","authorKeywords":"<string>","authorUrls":"<string>","contentType":"<string>","datePosted":"<string>","ignoreSources":"<string>","limit":"<integer>","mentioningMemberUrls":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","requireFields":"<string>","sort":"<string>","source":"<string>"}}'
```

### LinkedIn Profile Search

Search LinkedIn profiles by keyword with optional location and job-title filters. Each match returns a full profile record: name, headline, location, current position, work experience, education, and skills, plus the profile URL, handle, and id. For a cheaper name/headline/URL-only search use linkedin.search_profiles_thin; add emails with linkedin.search_profiles_email.

**Price:** billed per result - \$88.00 per 1,000 requests base + \$4.40 per 1,000 results, capped at \$198.00 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [LinkedIn Profile Search pricing and uptime](https://getanyapi.com/api/linkedin/search-profiles) - live USD price, lane routing, and measured 30-day uptime. [Every Linkedin endpoint](https://getanyapi.com/api/linkedin).

`POST /v1/run/linkedin.search_profiles`

**Cost:** Up to $0.21582 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.21582 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/84ad77b2-ecdb-486e-bd01-d50df42b95c9

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `companyHeadcount` | string | No | Filter by current company size (employee count). Codes: A=Self-Employed, B=1-10, C=11-50, D=51-200, E=201-500, F=501-1,000, G=1,001-5,000, H=5,001-10,000, I=10,001+. |
| `companyHeadquarterLocations` | string | No | Filter by the location of the person's current company headquarters, by place name (e.g. ['United States']). |
| `currentCompanies` | string | No | Filter to people who currently work at any of these companies, by name (e.g. ['Google','Meta']). Multiple names widen the match (OR). |
| `excludeCompanyHeadquarterLocations` | string | No | Exclude people whose current company is headquartered in any of these locations. |
| `excludeCurrentCompanies` | string | No | Exclude people who currently work at any of these companies, by name. |
| `excludeCurrentJobTitles` | string | No | Exclude people whose current job title matches any of these. |
| `excludeFunctionIds` | string | No | Exclude these job functions (same codes as functionIds). |
| `excludeLocations` | string | No | Exclude people in any of these locations, by place name. |
| `excludePastCompanies` | string | No | Exclude people who previously worked at any of these companies, by name. |
| `excludePastJobTitles` | string | No | Exclude people who held any of these past job titles. |
| `excludeSchools` | string | No | Exclude people who attended any of these schools, by name. |
| `excludeSeniorityLevelIds` | string | No | Exclude these seniority levels (same codes as seniorityLevelIds). |
| `firstNames` | string | No | Filter to people whose first name matches any of these. |
| `functionIds` | string | No | Filter by job function. Codes: 1=Accounting, 2=Administrative, 3=Arts and Design, 4=Business Development, 5=Community and Social Services, 6=Consulting, 7=Education, 8=Engineering, 9=Entrepreneurship, 10=Finance, 11=Healthcare Services, 12=Human Resources, 13=Information Technology, 14=Legal, 15=Marketing, 16=Media and Communication, 17=Military and Protective Services, 18=Operations, 19=Product Management, 20=Program and Project Management, 21=Purchasing, 22=Quality Assurance, 23=Real Estate, 2 |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `jobTitle` | string | No | Optional current job title filter (e.g. 'Software Engineer'). |
| `lastNames` | string | No | Filter to people whose last name matches any of these. |
| `limit` | integer | No | Maximum number of full profiles to return (1-25, default 10). You are billed per profile returned, so a lower limit costs less. |
| `location` | string | No | Optional location filter (e.g. 'San Francisco'). |
| `pastCompanies` | string | No | Filter to people who previously worked at any of these companies, by name. |
| `pastJobTitles` | string | No | Filter by a past job title the person held (e.g. ['Product Manager']). |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `profileLanguages` | string | No | Filter by the profile's primary language. |
| `query` | string | Yes | Search query for LinkedIn profiles: a role, name, or keywords (e.g. 'Marketing Manager'). |
| `recentlyChangedJobs` | boolean | No | When true, only return people who recently changed jobs (a strong sales/recruiting signal). |
| `recentlyPostedOnLinkedIn` | boolean | No | When true, only return people who recently posted on LinkedIn (an activity signal). |
| `schools` | string | No | Filter to people who attended any of these schools, by name. |
| `seniorityLevelIds` | string | No | Filter by seniority level. Codes: 100=In Training, 110=Entry Level, 120=Senior, 130=Strategic, 200=Entry Level Manager, 210=Experienced Manager, 220=Director, 300=Vice President, 310=CXO, 320=Owner/Partner. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `yearsAtCurrentCompanyIds` | string | No | Filter by tenure at the current company. Codes: 1=Less than 1 year, 2=1 to 2 years, 3=3 to 5 years, 4=6 to 10 years, 5=More than 10 years. |
| `yearsOfExperienceIds` | string | No | Filter by total years of experience. Codes: 1=Less than 1 year, 2=1 to 2 years, 3=3 to 5 years, 4=6 to 10 years, 5=More than 10 years. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/linkedin.search_profiles","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","companyHeadcount":"<string>","companyHeadquarterLocations":"<string>","currentCompanies":"<string>","excludeCompanyHeadquarterLocations":"<string>","excludeCurrentCompanies":"<string>","excludeCurrentJobTitles":"<string>","excludeFunctionIds":"<string>","excludeLocations":"<string>","excludePastCompanies":"<string>","excludePastJobTitles":"<string>","excludeSchools":"<string>","excludeSeniorityLevelIds":"<string>","firstNames":"<string>","functionIds":"<string>","ignoreSources":"<string>","jobTitle":"<string>","lastNames":"<string>","limit":"<integer>","location":"<string>","pastCompanies":"<string>","pastJobTitles":"<string>","preferLatencyUnderMs":"<integer>","profileLanguages":"<string>","query":"<string>","recentlyChangedJobs":"<boolean>","recentlyPostedOnLinkedIn":"<boolean>","schools":"<string>","seniorityLevelIds":"<string>","source":"<string>","yearsAtCurrentCompanyIds":"<string>","yearsOfExperienceIds":"<string>"}}'
```

### LinkedIn Profile Search (basic)

Cheap people search: name/handle, headline, VANITY profile URL, location. No full profile or email - for full profiles per hit use linkedin.search_profiles, add emails with linkedin.search_profiles_email.

**Price:** \$36.00 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [LinkedIn Profile Search (basic) pricing and uptime](https://getanyapi.com/api/linkedin/search-profiles-thin) - live USD price, lane routing, and measured 30-day uptime. [Every Linkedin endpoint](https://getanyapi.com/api/linkedin).

`POST /v1/run/linkedin.search_profiles_thin`

**Cost:** Up to $0.03488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.03488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/8c7dc319-6932-448c-82e1-7de0e41bfec6

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `currentCompanyId` | string | No | Filter by current employer, using a numeric LinkedIn company id. Comma-separate for several. |
| `cursor` | string | No | Opaque pagination cursor from a previous response's nextCursor. Omit for the first page; a page holds 10 profiles. |
| `firstName` | string | No | Filter by first name (e.g. Jane). |
| `followerOfUrn` | string | No | Return only people who follow this member, given the member's LinkedIn URN. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `industryId` | string | No | Filter by industry, using a LinkedIn industry id. |
| `lastName` | string | No | Filter by last name (e.g. Okafor). |
| `locationId` | string | No | Filter by location, using a LinkedIn geocode id. |
| `pastCompanyId` | string | No | Filter by a previous employer, using a numeric LinkedIn company id. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `profileLanguage` | string | No | Filter by the language the profile is written in (ISO 2-letter code, e.g. en). |
| `query` | string | Yes | Search query for LinkedIn profiles - a role, name, or keywords (e.g. 'Marketing Manager'). |
| `schoolId` | string | No | Filter by school, using a LinkedIn school id. |
| `serviceCategoryId` | string | No | Filter by service category, using a numeric service-category id. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `title` | string | No | Filter by job title or headline (e.g. Head of Talent). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/linkedin.search_profiles_thin","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","currentCompanyId":"<string>","cursor":"<string>","firstName":"<string>","followerOfUrn":"<string>","ignoreSources":"<string>","industryId":"<string>","lastName":"<string>","locationId":"<string>","pastCompanyId":"<string>","preferLatencyUnderMs":"<integer>","profileLanguage":"<string>","query":"<string>","schoolId":"<string>","serviceCategoryId":"<string>","source":"<string>","title":"<string>"}}'
```

### LinkedIn Service Provider Search

Find freelancers and service providers on LinkedIn by the service they offer (e.g. 'Web Development'), optionally in a location. One call returns a page of up to 10 people, each with name, headline, location, about text, photo, profile URL, service page URL, and the list of services they offer. The profile URL can be passed to linkedin.profile for the full record.

**Price:** \$2.60 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [LinkedIn Service Provider Search pricing and uptime](https://getanyapi.com/api/linkedin/search-services) - live USD price, lane routing, and measured 30-day uptime. [Every Linkedin endpoint](https://getanyapi.com/api/linkedin).

`POST /v1/run/linkedin.search_services`

**Cost:** Up to $0.002834 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.002834 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/a526a1a6-2a18-4489-88c5-8b6013978d7e

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `geoId` | string | No | LinkedIn geo id to target a precise location (e.g. 103644278 for the United States); more exact than the free-text location, and overrides it when both are sent. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `location` | string | No | Optional location filter as a place name (e.g. 'Australia', 'New York'). LinkedIn picks its closest location match, so a short or ambiguous name can land elsewhere; use geoId for an exact place. |
| `page` | integer | No | Which page of up to 10 people to return, starting at 1 (1-100, default 1). Each page is billed as one request. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | The service to search for, as keywords (e.g. 'Web Development', 'Accounting', 'Photography'). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/linkedin.search_services","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","geoId":"<string>","ignoreSources":"<string>","location":"<string>","page":"<integer>","preferLatencyUnderMs":"<integer>","query":"<string>","source":"<string>"}}'
```

### Linktree Profile

Get a public Linktree page by URL: title, bio, picture, contact email, linked social accounts, and every link card with its destination.

**Price:** \$1.10 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Linktree Profile pricing and uptime](https://getanyapi.com/api/linktree/profile) - live USD price, lane routing, and measured 30-day uptime. [Every Linktree endpoint](https://getanyapi.com/api/linktree).

`POST /v1/run/linktree.profile`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/c1b8525f-8fa9-41a9-ab47-792442a75b6f

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `title`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a page that |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | The Linktree profile URL, e.g. https://linktr.ee/mkbhd. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/linktree.profile","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>","url":"<string>"}}'
```

### RedNote (Xiaohongshu) Profile

Look up a RedNote (Xiaohongshu) profile by user ID and return normalized profile details.

**Price:** \$12.00 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [RedNote (Xiaohongshu) Profile pricing and uptime](https://getanyapi.com/api/rednote/profile) - live USD price, lane routing, and measured 30-day uptime. [Every Rednote endpoint](https://getanyapi.com/api/rednote).

`POST /v1/run/rednote.profile`

**Cost:** Up to $0.01308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.01308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/0ff924e7-bb74-4113-bd84-2529b344a850

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `userId` | string | Yes | RedNote (Xiaohongshu) user ID. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/rednote.profile","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","userId":"<string>"}}'
```

### Google Maps Contacts

Search Google Maps for businesses and enrich each result with contact details (emails, phones, and social profiles from their websites), up to 20 records per request.

**Price:** \$3.25 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Google Maps Contacts pricing and uptime](https://getanyapi.com/api/maps/contacts) - live USD price, lane routing, and measured 30-day uptime. [Every Maps endpoint](https://getanyapi.com/api/maps).

`POST /v1/run/maps.contacts`

**Cost:** Up to $0.108019 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.108019 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/e268d303-dedf-4b70-bfeb-5ea26907dfec

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `categoryFilterWords` | string | No | Optional list of Google Maps place-category names to keep; results are limited to places whose category matches one of these. Use lowercase category names as shown on Google Maps (e.g. ["dentist", "orthodontist"]). Omit to include all categories. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `language` | string | No | Two-letter language code for the results (e.g. en). |
| `limit` | integer | No | Maximum number of results to return (1-20, default 20). |
| `location` | string | Yes | Free-text location to search in, ideally city plus country (e.g. Denver, USA). |
| `placeMinimumStars` | string | No | Only return places with at least this average rating: two (2+), twoAndHalf (2.5+), three (3+), threeAndHalf (3.5+), four (4+), or fourAndHalf (4.5+). Places with no reviews are excluded. Omit for no rating filter. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | What you would type in the Google Maps search bar (e.g. dentist). |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `city` or `postalCode`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `website` | string | No | Filter places by whether they list a website: allPlaces (default), withWebsite (only places that have a website), or withoutWebsite (only places without one). Contact enrichment pulls emails and social profiles from a place's website, so withWebsite targets leads that can be enriched. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/maps.contacts","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","categoryFilterWords":"<string>","ignoreSources":"<string>","language":"<string>","limit":"<integer>","location":"<string>","placeMinimumStars":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","requireFields":"<string>","source":"<string>","website":"<string>"}}'
```

### Google Maps Place Lookup

Look up a place on Google Maps by name or search query (optionally scoped to a location) and get the best-matching place with available address, contact, rating, and coordinate details as normalized JSON.

**Price:** \$1.75 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Google Maps Place Lookup pricing and uptime](https://getanyapi.com/api/maps/place) - live USD price, lane routing, and measured 30-day uptime. [Every Maps endpoint](https://getanyapi.com/api/maps).

`POST /v1/run/maps.place`

**Cost:** Up to $0.010791 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.010791 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/17fd190c-985e-46df-b7ef-9e616d047b77

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `categoryFilterWords` | string | No | Optional list of Google Maps place-category names to keep; the match is limited to a place whose category is one of these. Use lowercase category names as shown on Google Maps (e.g. ["coffee shop"]). Omit to allow any category and stay on the cheapest price; a category filter routes to a dearer source. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `language` | string | No | Two-letter language code for the result details (e.g. en). |
| `location` | string | No | Optional free-text location to scope the search, ideally city plus state or country (e.g. San Francisco, CA). Narrows the query to the best match in that area. |
| `placeMinimumStars` | string | No | Only match a place with at least this average rating: two (2+), twoAndHalf (2.5+), three (3+), threeAndHalf (3.5+), four (4+), or fourAndHalf (4.5+). Places with no reviews are excluded. Omit this field to stay on the cheapest price; a rating floor routes to a dearer source. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | The business name or search text to look up, as you would type it into the Google Maps search bar (e.g. Blue Bottle Coffee). |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `plusCode` or `postalCode`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be ab |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `website` | string | No | Filter by whether the place lists a website: allPlaces (default), withWebsite (only if it has a website), or withoutWebsite (only if it has none). Omit this field, or send allPlaces, to stay on the cheapest price; withWebsite and withoutWebsite route to a dearer source. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/maps.place","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","categoryFilterWords":"<string>","ignoreSources":"<string>","language":"<string>","location":"<string>","placeMinimumStars":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","requireFields":"<string>","source":"<string>","website":"<string>"}}'
```

### Google Maps Reviews

Fetch up to 100 Google Maps reviews for a place by place ID, sorted the way you need, in one normalized response.

**Price:** billed per result - \$0.15 per 1,000 requests base + \$0.02 per 1,000 results, capped at \$2.15 per 1,000 requests.

**Routing:** 5 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Google Maps Reviews pricing and uptime](https://getanyapi.com/api/maps/reviews) - live USD price, lane routing, and measured 30-day uptime. [Every Maps endpoint](https://getanyapi.com/api/maps).

`POST /v1/run/maps.reviews`

**Cost:** Up to $0.036079 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.036079 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/b87ea43c-febc-403c-8da7-7f5792469c10

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `language` | string | No | Two-letter language code for the review details (e.g. en). |
| `limit` | integer | No | Maximum number of results to return (1-100, default 100). |
| `placeId` | string | Yes | The Google Maps place ID to fetch reviews for (e.g. ChIJj61dQgK6j4AR4GeTYWZsKWw). |
| `postedLimit` | string | No | Only return reviews posted within this window: 24h (past 24 hours), week (past 7 days), month (past month), or year (past year). Omit for no recency filter. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `isLocalGuide` or `placeId`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be a |
| `reviewsFilterString` | string | No | Only return reviews that Google's review search matches for this keyword or phrase. It matches whole words, case-insensitive, so mail does not match email. Omit to return all reviews (e.g. parking). |
| `sort` | string | No | Order in which reviews are returned (e.g. newest). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/maps.reviews","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","language":"<string>","limit":"<integer>","placeId":"<string>","postedLimit":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","reviewsFilterString":"<string>","sort":"<string>","source":"<string>"}}'
```

### Google Maps Search

Search Google Maps for places matching a query and location: up to 20 normalized place records with ratings, addresses, and contact basics per request.

**Price:** \$1.75 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 4 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Google Maps Search pricing and uptime](https://getanyapi.com/api/maps/search) - live USD price, lane routing, and measured 30-day uptime. [Every Maps endpoint](https://getanyapi.com/api/maps).

`POST /v1/run/maps.search`

**Cost:** Up to $0.076845 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.076845 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/3bba5af7-ed8e-455e-8ba5-c72cc9678684

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `categoryFilterWords` | string | No | Optional list of Google Maps place-category names to keep; results are limited to places whose category matches one of these. Use lowercase category names as shown on Google Maps (e.g. ["coffee shop", "restaurant"]). Omit to include all categories and stay on the cheapest price; a category filter routes to a dearer source. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `language` | string | No | Two-letter language code for the results (e.g. en). |
| `limit` | integer | No | Maximum number of results to return (1-20, default 20). Pricing depends on the selected provider and may be flat per request. |
| `location` | string | Yes | Free-text location to search in, ideally city plus country (e.g. Austin, USA). |
| `placeMinimumStars` | string | No | Only return places with at least this average rating: two (2+), twoAndHalf (2.5+), three (3+), threeAndHalf (3.5+), four (4+), or fourAndHalf (4.5+). Places with no reviews are excluded. Omit this field to stay on the cheapest price; a rating floor routes to a dearer source. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | What you would type in the Google Maps search bar (e.g. coffee shop). |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `cid` or `street`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `website` | string | No | Filter places by whether they list a website: allPlaces (default), withWebsite (only places that have a website), or withoutWebsite (only places without one). Omit this field, or send allPlaces, to stay on the cheapest price; withWebsite and withoutWebsite route to a dearer source. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/maps.search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","categoryFilterWords":"<string>","ignoreSources":"<string>","language":"<string>","limit":"<integer>","location":"<string>","placeMinimumStars":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","requireFields":"<string>","source":"<string>","website":"<string>"}}'
```

### Google Maps Nearby Search

Search Google Maps around an exact latitude and longitude and get up to 20 normalized places per call, each with the address broken into street, city, state, postal code and country. Use this when you have coordinates and want the map viewport centred on them; use maps.search when you only have a place name. Pass the returned nextCursor back as cursor for the next 20 places.

**Price:** \$1.30 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Google Maps Nearby Search pricing and uptime](https://getanyapi.com/api/maps/search-nearby) - live USD price, lane routing, and measured 30-day uptime. [Every Maps endpoint](https://getanyapi.com/api/maps).

`POST /v1/run/maps.search_nearby`

**Cost:** Up to $0.001417 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001417 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/26c2d28a-0bd4-4bda-bb37-b63276ccb50c

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `coordinates` | object | Yes | The exact map centre to search around. Use maps.search instead if you only have a place name. |
| `cursor` | string | No | Opaque cursor from a previous response's nextCursor. Pass it back to get the next page of places. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `language` | string | No | Two-letter language code for the results (e.g. en). |
| `limit` | integer | No | Accepted but does not change the page: every call returns one full Google Maps viewport of about 20 places, never trimmed, so nextCursor continues exactly where this response ended. Price is flat per request. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | What you would type in the Google Maps search bar (e.g. coffee shop). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `zoom` | number | No | Google Maps viewport zoom. Lower covers a wider area, higher focuses more tightly around the coordinates. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/maps.search_nearby","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","coordinates":"<object>","cursor":"<string>","ignoreSources":"<string>","language":"<string>","limit":"<integer>","preferLatencyUnderMs":"<integer>","query":"<string>","source":"<string>","zoom":"<number>"}}'
```

### Naver Blog Search

Search up to five enriched Naver blog results by keyword with stable cursor pagination: result rank, title, excerpt, post and blogger URLs, blogger name, publish time, and Naver's total match count.

**Price:** \$36.00 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Naver Blog Search pricing and uptime](https://getanyapi.com/api/naver/blog-search) - live USD price, lane routing, and measured 30-day uptime. [Every Naver endpoint](https://getanyapi.com/api/naver).

`POST /v1/run/naver.blog_search`

**Cost:** Up to $0.03488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.03488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/e3625b5c-c7f6-4349-b16b-0801c4a62ace

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Opaque pagination cursor from a previous response's nextCursor. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum number of title-enriched posts to return, from 1 to 5 (default 5). |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Keyword phrase to search across Naver blogs. |
| `sort` | string | No | Order posts by Naver relevance or newest publication date (default relevance). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/naver.blog_search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","ignoreSources":"<string>","limit":"<integer>","preferLatencyUnderMs":"<integer>","query":"<string>","sort":"<string>","source":"<string>"}}'
```

### Nextdoor Business

Fetch one Nextdoor business page by its slug, with phone, email, website, and street address.

**Price:** billed per result - \$5.50 per 1,000 requests base + \$2.86 per 1,000 results, capped at \$8.36 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Nextdoor Business pricing and uptime](https://getanyapi.com/api/nextdoor/business) - live USD price, lane routing, and measured 30-day uptime. [Every Nextdoor endpoint](https://getanyapi.com/api/nextdoor).

`POST /v1/run/nextdoor.business`

**Cost:** Up to $0.008633 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.008633 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/d18aeb0f-dc22-45aa-8917-5ca881d85723

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum number of records to return. A business page resolves to one record, so this is always 1. |
| `market` | string | No | Nextdoor market the page belongs to: "us" (nextdoor.com), "gb" (nextdoor.co.uk), or "ca" (ca.nextdoor.com). Defaults to "us". |
| `pageSlug` | string | Yes | Slug of the Nextdoor business page, the last path segment of its /pages/ URL, e.g. "radiant-plumbing-air-conditioning-austin-tx". |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/nextdoor.business","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","limit":"<integer>","market":"<string>","pageSlug":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### Perplexity Search

Ask Perplexity a web-grounded question and receive an answer with source citations.

**Price:** \$2.00 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Perplexity Search pricing and uptime](https://getanyapi.com/api/perplexity/search) - live USD price, lane routing, and measured 30-day uptime. [Every Perplexity endpoint](https://getanyapi.com/api/perplexity).

`POST /v1/run/perplexity.search`

**Cost:** Up to $0.010856 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.010856 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/aec6cf9c-8ec1-4d15-9076-36b7500eb1b0

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `prompt` | string | Yes | Question or research prompt for Perplexity to answer using web search. |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `createdUtc`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a resu |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/perplexity.search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","prompt":"<string>","requireFields":"<string>","source":"<string>"}}'
```

### Pexels Photo Search

Search Pexels for free stock photos by keyword. Returns image URLs in several sizes, dimensions, alt text, the photographer's name and profile, and the photo's Pexels page.

**Price:** billed per result - \$0.55 per 1,000 requests base + \$3.30 per 1,000 results, capped at \$66.60 per 1,000 requests.

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Pexels Photo Search pricing and uptime](https://getanyapi.com/api/pexels/search-photos) - live USD price, lane routing, and measured 30-day uptime. [Every Pexels endpoint](https://getanyapi.com/api/pexels).

`POST /v1/run/pexels.search_photos`

**Cost:** Up to $0.101588 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.101588 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/9894cff2-e1a7-4061-810b-f342509b62fc

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum number of photos to return (1-20, default 20). You are billed per photo returned, so a lower limit costs less. |
| `minHeight` | integer | No | Only return photos at least this many pixels tall. |
| `minWidth` | integer | No | Only return photos at least this many pixels wide. |
| `orientation` | string | No | Only return photos with this orientation. Omit for any orientation. |
| `peopleCount` | string | No | Only return photos showing this many people: "0" for none, "1" or "2". Omit for any number. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Keyword or phrase to search Pexels photos for, e.g. "coffee" or "city skyline". |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `tags`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a photo that |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/pexels.search_photos","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","limit":"<integer>","minHeight":"<integer>","minWidth":"<integer>","orientation":"<string>","peopleCount":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","requireFields":"<string>","source":"<string>"}}'
```

### Pinterest Pin

Fetch one public Pinterest pin by URL or numeric pin id: title, description, image, video, outbound link and site, save count, hashtags, the pinner with their follower count, and the board it was saved to, as normalized JSON. A pin that does not exist is not charged.

**Price:** \$0.85 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Pinterest Pin pricing and uptime](https://getanyapi.com/api/pinterest/pin) - live USD price, lane routing, and measured 30-day uptime. [Every Pinterest endpoint](https://getanyapi.com/api/pinterest).

`POST /v1/run/pinterest.pin`

**Cost:** Up to $0.000927 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.000927 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/9692c1d6-1d12-42ee-affe-f458ff5e834e

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `pinId` | string | No | Numeric Pinterest pin id, the number in the pin URL (https://www.pinterest.com/pin/<id>/), e.g. 101049585382283341. Pinterest Search returns it as id. Send this or url. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | No | Full Pinterest pin URL carrying the numeric pin id, e.g. https://www.pinterest.com/pin/101049585382283341/. Country sites such as uk.pinterest.com or pinterest.de work too. pin.it short links are not accepted: open the link in a browser and send the pinterest.com/pin/... address it lands on. Send this or pinId. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/pinterest.pin","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","pinId":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### Pinterest Search

Search Pinterest by keyword and get pin, video, board, or profile results with titles, images, and links.

**Price:** \$3.60 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Pinterest Search pricing and uptime](https://getanyapi.com/api/pinterest/search) - live USD price, lane routing, and measured 30-day uptime. [Every Pinterest endpoint](https://getanyapi.com/api/pinterest).

`POST /v1/run/pinterest.search`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/d271b807-4de0-4233-8bf1-641dc8338b76

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Opaque pagination cursor from a previous response's nextCursor. Omit for the first page. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Page size to ask for (1-20). Some sources return their whole page of about 20 pins whatever limit says: a page is never trimmed after the call, so nextCursor continues exactly where this response ended. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Keyword, topic, brand, or theme to search Pinterest for (e.g. mid-century living room). |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `description` or `videoUrl`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be n |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `type` | string | No | Kind of results to return: all pins, only video pins, boards, or profiles (e.g. videos). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/pinterest.search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","ignoreSources":"<string>","limit":"<integer>","preferLatencyUnderMs":"<integer>","query":"<string>","requireFields":"<string>","source":"<string>","type":"<string>"}}'
```

### Google Play App Details

Get an Android app's Google Play listing by package name, in any store country: title, developer and contact details, rating, ratings count, installs, price, description, screenshots, and more.

**Price:** \$0.85 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Google Play App Details pricing and uptime](https://getanyapi.com/api/playstore/app) - live USD price, lane routing, and measured 30-day uptime. [Every Playstore endpoint](https://getanyapi.com/api/playstore).

`POST /v1/run/playstore.app`

**Cost:** Up to $0.000927 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.000927 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/b4f016a3-4fa0-4957-ac77-840784e6f91a

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `appId` | string | Yes | Android app package name, the id parameter of the app's Google Play URL (e.g. com.supercell.brawlstars). |
| `country` | string | No | Two-letter Google Play store country code to read the listing from (e.g. gb); price and currency follow that country. Text is returned in English. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `reviewCount` or `developerEmail`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can stil |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/playstore.app","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","appId":"<string>","country":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>"}}'
```

### Google Play Reviews

Fetch Google Play reviews for any Android app by package name or store URL: ratings, review text, dates, and helpfulness votes.

**Price:** \$0.90 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Google Play Reviews pricing and uptime](https://getanyapi.com/api/playstore/reviews) - live USD price, lane routing, and measured 30-day uptime. [Every Playstore endpoint](https://getanyapi.com/api/playstore).

`POST /v1/run/playstore.reviews`

**Cost:** Up to $0.01744 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.01744 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/6fa71b0e-baf2-42a7-a3f8-1993043d1663

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `appId` | string | Yes | Android app package name or full Google Play store URL (e.g. com.supercell.brawlstars). |
| `appVersion` | string | No | Only return reviews left on these app versions (e.g. ["2.24.1", "2.24.2"]). |
| `deviceType` | string | No | Only return reviews from this device type (e.g. "tablet"); omit for the provider default. |
| `endDate` | string | No | Only return reviews on or before this date, inclusive, in YYYY-MM-DD format (e.g. 2026-06-30). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `keywords` | string | No | Only return reviews whose text contains one of these keywords (e.g. ["crash", "login"]). |
| `languages` | string | No | Only return reviews in these ISO 639-1 languages (e.g. ["en", "es"]). |
| `limit` | integer | No | Maximum number of results to return (1-100, default 100). |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `rating` | integer | No | Only return reviews with this exact star rating from 1 to 5 (e.g. 1); omit for all ratings. |
| `recentDays` | integer | No | Only return reviews from the last N days (e.g. 30); omit for no time limit. |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `title` or `appId`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on |
| `sortBy` | string | No | Review ordering: mostRelevant, newest, or rating (e.g. newest). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/playstore.reviews","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","appId":"<string>","appVersion":"<string>","deviceType":"<string>","endDate":"<string>","ignoreSources":"<string>","keywords":"<string>","languages":"<string>","limit":"<integer>","preferLatencyUnderMs":"<integer>","rating":"<integer>","recentDays":"<integer>","requireFields":"<string>","sortBy":"<string>","source":"<string>"}}'
```

### Polymarket Markets

Discover Polymarket prediction markets (question, outcome prices, volume, liquidity, and end dates) by keyword or sorted by activity, as normalized JSON.

**Price:** billed per result - \$116.00 per 1,000 requests base + \$0.66 per 1,000 results, capped at \$132.00 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Polymarket Markets pricing and uptime](https://getanyapi.com/api/polymarket/markets) - live USD price, lane routing, and measured 30-day uptime. [Every Polymarket endpoint](https://getanyapi.com/api/polymarket).

`POST /v1/run/polymarket.markets`

**Cost:** Up to $0.14388 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.14388 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/3af769d4-f645-4a5f-a8bd-da20d390d253

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum number of results to return (10-25, default 25). You are billed per result returned, so a lower limit costs less. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Search term for markets (e.g. election, bitcoin, super bowl). |
| `sortBy` | string | No | How discovered markets are ordered before results are returned (e.g. volume_24hr for recent momentum). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `status` | string | No | Return "active" markets for current prices and volume, or "resolved" markets for historical outcomes. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/polymarket.markets","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","limit":"<integer>","preferLatencyUnderMs":"<integer>","query":"<string>","sortBy":"<string>","source":"<string>","status":"<string>"}}'
```

### Property Records - Enformion

Look up the public property records for one US address: current and previous owners, parcel number (APN), last sale, assessed and market values, property tax, beds, baths, living area, lot size, year built, land use, and zoning. One address can match several parcels, and every match is returned. Billed only when a record is found.

**Price:** \$153.60 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Property Records - Enformion pricing and uptime](https://getanyapi.com/api/property-records/enformion) - live USD price, lane routing, and measured 30-day uptime. [Every Property_records endpoint](https://getanyapi.com/api/property-records).

`POST /v1/run/property_records.enformion`

**Cost:** Up to $0.167424 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.167424 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/99978942-82b1-4161-95d5-545a0804bbaf

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `city` | string | Yes | City of the property, e.g. Austin. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `state` | string | Yes | US state of the property, as its two-letter code, e.g. TX. |
| `street` | string | Yes | Street line of one US property address, e.g. 4510 Secure Ln. Include a unit number when there is one. |
| `zip` | string | No | Five-digit ZIP code, optionally with its four-digit extension, e.g. 78725. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/property_records.enformion","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","city":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","state":"<string>","street":"<string>","zip":"<string>"}}'
```

### Realtor.com Search

Search Realtor.com listings by location with optional price, property-type, beds/baths, listing-status, and keyword filters and get property records (price, address, beds, baths) as normalized JSON.

**Price:** billed per result - \$5.50 per 1,000 requests base + \$1.65 per 1,000 results, capped at \$46.80 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Realtor.com Search pricing and uptime](https://getanyapi.com/api/realtor/search) - live USD price, lane routing, and measured 30-day uptime. [Every Realtor endpoint](https://getanyapi.com/api/realtor).

`POST /v1/run/realtor.search`

**Cost:** Up to $0.051012 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.051012 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/d0d50a97-e82c-4bd0-8104-e469db863a16

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `bathsMin` | integer | No | Minimum number of bathrooms (e.g. 2). |
| `bedsMin` | integer | No | Minimum number of bedrooms (e.g. 3). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `keyword` | string | No | Free-text keyword that must appear in the listing description (e.g. 'pool'). |
| `limit` | integer | No | Maximum number of results to return (1-25, default 25). You are billed per result returned, so a lower limit costs less. |
| `location` | string | Yes | City, ZIP code, neighborhood or state to search (e.g. Las Vegas, NV). |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `priceMax` | integer | No | Maximum listing price in USD (e.g. 750000). |
| `priceMin` | integer | No | Minimum listing price in USD (e.g. 250000). |
| `propertyTypes` | string | No | Filter by one or more property types; omit for all types (e.g. ["single_family", "townhomes"]). |
| `searchMode` | string | No | Listing type to search: for_sale or sold (e.g. for_sale). |
| `searchStatuses` | string | No | Listing statuses to include in for_sale mode; omit for active For Sale + Ready to Build. Ignored in sold mode (e.g. ["for_sale", "pending"]). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/realtor.search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","bathsMin":"<integer>","bedsMin":"<integer>","ignoreSources":"<string>","keyword":"<string>","limit":"<integer>","location":"<string>","preferLatencyUnderMs":"<integer>","priceMax":"<integer>","priceMin":"<integer>","propertyTypes":"<string>","searchMode":"<string>","searchStatuses":"<string>","source":"<string>"}}'
```

### Reddit Avatar

Get a Reddit user's profile picture URL, karma, and account age by username. The cheapest Reddit user lookup; use reddit.profile for bio, trophies, and post and comment counts.

**Price:** \$0.38 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Reddit Avatar pricing and uptime](https://getanyapi.com/api/reddit/avatar) - live USD price, lane routing, and measured 30-day uptime. [Every Reddit endpoint](https://getanyapi.com/api/reddit).

`POST /v1/run/reddit.avatar`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/b0fa845e-1e52-42e9-a55a-fb84bf0c0a23

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `username` | string | Yes | Reddit username, without the u/ prefix. Example: "spez". |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/reddit.avatar","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","username":"<string>"}}'
```

### Reddit Post

Fetch a single Reddit post by URL, including its full body text, score, comment count, upvote ratio, and subreddit, as normalized JSON.

**Price:** \$0.50 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 4 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Reddit Post pricing and uptime](https://getanyapi.com/api/reddit/post) - live USD price, lane routing, and measured 30-day uptime. [Every Reddit endpoint](https://getanyapi.com/api/reddit).

`POST /v1/run/reddit.post`

**Cost:** Up to $0.002442 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.002442 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/6e299166-e0cd-4003-a82f-9d2fed83b47f

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Reddit post URL on reddit.com, e.g. "https://www.reddit.com/r/IAmA/comments/z1c9z/i_am_barack_obama_president_of_the_united_states/". The /r/<subreddit>/comments/<id>/, /user/<name>/comments/<id>/, /comments/<id>/ and /gallery/<id> forms are accepted. Any other link, such as a share link or a link to another site, is refused as invalid input, with no charge. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/reddit.post","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### Reddit Post Comments

List the comments on a Reddit post by URL (author, body, score, timestamp, parent comment). Replies carry the parentId of the comment they answer.

**Price:** \$0.60 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Reddit Post Comments pricing and uptime](https://getanyapi.com/api/reddit/post-comments) - live USD price, lane routing, and measured 30-day uptime. [Every Reddit endpoint](https://getanyapi.com/api/reddit).

`POST /v1/run/reddit.post_comments`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/e0f520d3-d78d-4951-b0c9-ac550317bafa

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Cursor from a previous response for more comments. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Full Reddit post URL on reddit.com. A gallery link (https://www.reddit.com/gallery/<id>) is read as the post it belongs to, and a relative permalink (/r/<subreddit>/comments/<id>/...) as the same path on https://www.reddit.com. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/reddit.post_comments","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### Reddit Post Transcript

Extract the spoken transcript from a Reddit video post by URL.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Reddit Post Transcript pricing and uptime](https://getanyapi.com/api/reddit/post-transcript) - live USD price, lane routing, and measured 30-day uptime. [Every Reddit endpoint](https://getanyapi.com/api/reddit).

`POST /v1/run/reddit.post_transcript`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/f9f16ee1-53b3-4a69-a335-7c13252e47cd

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `language` | string | No | Optional two-letter language code (defaults to en). |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Reddit post URL or direct v.redd.it video URL to transcribe. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/reddit.post_transcript","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","language":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### Reddit Profile

Fetch a Reddit user's public profile (karma split, post and comment counts, bio, avatar, account age) by username.

**Price:** \$0.80 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Reddit Profile pricing and uptime](https://getanyapi.com/api/reddit/profile) - live USD price, lane routing, and measured 30-day uptime. [Every Reddit endpoint](https://getanyapi.com/api/reddit).

`POST /v1/run/reddit.profile`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/f675cf67-1e23-4b94-872b-ef92ccaad155

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `verified`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a profil |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `username` | string | Yes | Reddit username, without the u/ prefix. Example: "spez". |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/reddit.profile","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>","username":"<string>"}}'
```

### Reddit Search

Search Reddit posts across all subreddits by query.

**Price:** \$0.35 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 4 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Reddit Search pricing and uptime](https://getanyapi.com/api/reddit/search) - live USD price, lane routing, and measured 30-day uptime. [Every Reddit endpoint](https://getanyapi.com/api/reddit).

`POST /v1/run/reddit.search`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/e58dad8c-18c6-4f3c-b5b6-a215663886f5

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Opaque pagination cursor from a previous response's nextCursor. Omit for the first page; pass it to fetch the next page of results. Include `nextCursor` in requireFields on the first request to make sure a source that supports pagination serves it. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Free-text search across all of Reddit. Reddit's field operators are supported inside the string: subreddit:<name> to scope to one subreddit, author:<user>, title:<text>, selftext:<text>, self:yes\|no, nsfw:yes\|no, and boolean AND/OR/NOT. To restrict to a single subreddit you can use subreddit:<name> here, or use the reddit.subreddit_posts SKU for a plain subreddit listing. |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `nextCursor` or `media`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. Name `nextCursor` only if you wi |
| `sort` | string | No | Result sort order. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `timeframe` | string | No | Time window for results. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/reddit.search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","requireFields":"<string>","sort":"<string>","source":"<string>","timeframe":"<string>"}}'
```

### Reddit Subreddit Details

Fetch a subreddit's metadata (weekly active users, description, and category).

**Price:** \$0.38 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Reddit Subreddit Details pricing and uptime](https://getanyapi.com/api/reddit/subreddit-details) - live USD price, lane routing, and measured 30-day uptime. [Every Reddit endpoint](https://getanyapi.com/api/reddit).

`POST /v1/run/reddit.subreddit_details`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/8743aab7-ed5f-4657-999e-ca6648cc701d

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `weeklyActiveUsers` or `advertiserCategory`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named fiel |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `subreddit` | string | Yes | Subreddit name without the r/ prefix. Case-sensitive (e.g. "AskReddit", not "askreddit"). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/reddit.subreddit_details","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>","subreddit":"<string>"}}'
```

### Reddit Subreddit Search

Search posts within a single subreddit by query, sort, and timeframe.

**Price:** \$0.35 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 5 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Reddit Subreddit Search pricing and uptime](https://getanyapi.com/api/reddit/subreddit-search) - live USD price, lane routing, and measured 30-day uptime. [Every Reddit endpoint](https://getanyapi.com/api/reddit).

`POST /v1/run/reddit.subreddit_search`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/f8df9eaf-b0ea-40f9-a9d8-2dbf58b9a9bf

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Optional pagination token from a previous response. Include `nextCursor` in requireFields on the first request to make sure a source that supports pagination serves it. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | No | Optional search query to match posts (e.g. 'push ups'). |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `nextCursor` or `selftext`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. Name `nextCursor` only if you |
| `sort` | string | No | Optional sort order: relevance, hot, top, new, comments. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `subreddit` | string | Yes | Subreddit name without the r/ prefix (e.g. 'Fitness'). |
| `timeframe` | string | No | Optional time filter: all, year, month, week, day, hour. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/reddit.subreddit_search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","requireFields":"<string>","sort":"<string>","source":"<string>","subreddit":"<string>","timeframe":"<string>"}}'
```

### Reddit User Comments

List a Reddit user's comments by username, sorted by new, top, hot, or controversial, with the parent post title and subreddit on every item and cursor pagination. Comment text may be truncated to a roughly 300-character preview, and this endpoint carries no per-comment permalink; use reddit.post_comments for full comment bodies and comment URLs on a given post.

**Price:** \$0.60 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Reddit User Comments pricing and uptime](https://getanyapi.com/api/reddit/user-comments) - live USD price, lane routing, and measured 30-day uptime. [Every Reddit endpoint](https://getanyapi.com/api/reddit).

`POST /v1/run/reddit.user_comments`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/d2be8963-efaa-4b01-a26d-05f63873e24e

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Opaque pagination cursor from a previous response's nextCursor. Omit for the first page; pass it back to fetch the next page. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Page size to ask for (up to 100, default 25). Some sources honor it; others always return their whole page of about 25 comments. A page is never trimmed after the call, so pass nextCursor back as cursor to continue exactly where this response ended. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `sort` | string | No | Sort order for the user's comments. Defaults to new (most recent first). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `username` | string | Yes | Reddit username, without the u/ prefix. Example: "spez". |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/reddit.user_comments","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","ignoreSources":"<string>","limit":"<integer>","preferLatencyUnderMs":"<integer>","sort":"<string>","source":"<string>","username":"<string>"}}'
```

### Reddit User Posts

List a Reddit user's posts by username, sorted by new, top, hot, or controversial, with cursor pagination.

**Price:** \$0.38 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Reddit User Posts pricing and uptime](https://getanyapi.com/api/reddit/user-posts) - live USD price, lane routing, and measured 30-day uptime. [Every Reddit endpoint](https://getanyapi.com/api/reddit).

`POST /v1/run/reddit.user_posts`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/6ed1ee1f-ee81-44d2-bd07-248e8eeb23ff

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Opaque pagination cursor from a previous response's nextCursor. Omit for the first page; pass it back to fetch the next page. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `isArchived` or `isLocked`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be ab |
| `sort` | string | No | Sort order for the user's posts. Defaults to new (most recent first). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `username` | string | Yes | Reddit username without the leading u/ prefix (e.g. "spez"). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/reddit.user_posts","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","sort":"<string>","source":"<string>","username":"<string>"}}'
```

### Redfin Search

Run a Redfin map search by URL and get matching home listings (price, address, beds, baths, status) as normalized JSON.

**Price:** \$0.80 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Redfin Search pricing and uptime](https://getanyapi.com/api/redfin/search) - live USD price, lane routing, and measured 30-day uptime. [Every Redfin endpoint](https://getanyapi.com/api/redfin).

`POST /v1/run/redfin.search`

**Cost:** Up to $0.014824 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.014824 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/08e0c742-d30b-4a5c-8bae-01c6e10d2303

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum number of results to return (1-25, default 25). |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `description`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a lis |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Redfin search results URL for a city, ZIP or map area (e.g. https://www.redfin.com/city/30772/CA/San-Francisco). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/redfin.search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","limit":"<integer>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>","url":"<string>"}}'
```

### RedNote (Xiaohongshu) Note

Look up a RedNote (Xiaohongshu) note by note ID and return normalized note details.

**Price:** \$12.00 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [RedNote (Xiaohongshu) Note pricing and uptime](https://getanyapi.com/api/rednote/note) - live USD price, lane routing, and measured 30-day uptime. [Every Rednote endpoint](https://getanyapi.com/api/rednote).

`POST /v1/run/rednote.note`

**Cost:** Up to $0.01308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.01308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/e1e0a255-e845-4f5d-8681-96ee7fd64b69

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `noteId` | string | Yes | RedNote (Xiaohongshu) note ID. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/rednote.note","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","noteId":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### SEC EDGAR Filings

List a public company's SEC EDGAR filings - form type, filing date, accession number, and document links - by ticker, company name, or CIK, with optional form-type and date filters.

**Price:** billed per result - \$2.20 per 1,000 requests base + \$0.44 per 1,000 results, capped at \$13.20 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [SEC EDGAR Filings pricing and uptime](https://getanyapi.com/api/sec/filings) - live USD price, lane routing, and measured 30-day uptime. [Every Sec endpoint](https://getanyapi.com/api/sec).

`POST /v1/run/sec.filings`

**Cost:** Up to $0.014388 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.014388 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/1f4fbeea-75b9-421e-83c4-f0aa60fe0be5

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `companyName` | string | No | Company name to search for (partial match supported, e.g. 'Tesla' or 'Berkshire'). Use this when you do not have the ticker symbol. If both ticker and companyName are given, ticker takes precedence. |
| `dateFrom` | string | No | Only return filings filed on or after this date, in YYYY-MM-DD format (e.g. 2025-01-01). |
| `dateTo` | string | No | Only return filings filed on or before this date, in YYYY-MM-DD format (e.g. 2026-06-01). |
| `form` | string | No | Filter filings by SEC form type (e.g. 10-K, 10-Q, 8-K, 4, DEF 14A, S-1, 13F-HR); omit for all forms. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum number of filings to return (1-25, default 25). You are billed per result returned, so a lower limit costs less. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `ticker` | string | No | Company stock ticker symbol, e.g. AAPL, MSFT, or TSLA. Provide either ticker or companyName; ticker is the more precise lookup. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/sec.filings","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","companyName":"<string>","dateFrom":"<string>","dateTo":"<string>","form":"<string>","ignoreSources":"<string>","limit":"<integer>","preferLatencyUnderMs":"<integer>","source":"<string>","ticker":"<string>"}}'
```

### Semrush Keyword Research

Semrush keyword research for any term: monthly search volume, CPC, competition, keyword difficulty, plus related keywords and question keywords.

**Price:** billed per result - \$4.95 per 1,000 results, capped at \$4.95 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Semrush Keyword Research pricing and uptime](https://getanyapi.com/api/semrush/keywords) - live USD price, lane routing, and measured 30-day uptime. [Every Semrush endpoint](https://getanyapi.com/api/semrush).

`POST /v1/run/semrush.keywords`

**Cost:** Up to $0.005396 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.005396 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/abfca943-fadf-4abc-9db0-7b0ff9404c58

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `database` | string | No | Two-letter Semrush regional database that scopes the metrics (e.g. us, uk, de). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `keyword` | string | Yes | The search term to research (e.g. "best running shoes"). |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/semrush.keywords","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","database":"<string>","ignoreSources":"<string>","keyword":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### Semrush Domain Overview

a Semrush SEO overview for any domain: Authority Score, organic and paid traffic, keyword and backlink counts, top country, and the domain's top organic keywords.

**Price:** billed per result - \$4.95 per 1,000 results, capped at \$4.95 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Semrush Domain Overview pricing and uptime](https://getanyapi.com/api/semrush/overview) - live USD price, lane routing, and measured 30-day uptime. [Every Semrush endpoint](https://getanyapi.com/api/semrush).

`POST /v1/run/semrush.overview`

**Cost:** Up to $0.005396 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.005396 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/da50f6bc-cd37-4ee1-9b77-08e756ca88b9

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `database` | string | No | Two-letter Semrush regional database that scopes the metrics (e.g. us, uk, de). |
| `domain` | string | Yes | The domain to analyze (e.g. ahrefs.com). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `includeMoz` | boolean | No | Add Moz Domain Authority and Spam Score to the response. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/semrush.overview","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","database":"<string>","domain":"<string>","ignoreSources":"<string>","includeMoz":"<boolean>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### SEO Backlink Anchors

Get AnyAPI SEO anchor texts of the backlinks pointing at a domain or URL, each with backlink and referring domain counts, authority rank, and spam score as normalized JSON.

**Price:** billed per result - \$28.80 per 1,000 requests base + \$0.05 per 1,000 results, capped at \$76.80 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [SEO Backlink Anchors pricing and uptime](https://getanyapi.com/api/seo/backlink-anchors) - live USD price, lane routing, and measured 30-day uptime. [Every Seo endpoint](https://getanyapi.com/api/seo).

`POST /v1/run/seo.backlink_anchors`

**Cost:** Up to $0.083712 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.083712 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/430888bb-1682-4b6a-b547-ecb54d6201c6

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `includeSubdomains` | boolean | No | Count links pointing at the target's subdomains as well as the target itself. |
| `limit` | integer | No | Maximum number of anchor texts to return. You are billed per returned result, so a lower limit costs less. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `status` | string | No | Count backlinks that are live now, ones that have been lost, or both. |
| `target` | string | Yes | Domain, subdomain, or full page URL to analyze. Send a domain without a protocol or leading www. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/seo.backlink_anchors","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","includeSubdomains":"<boolean>","limit":"<integer>","preferLatencyUnderMs":"<integer>","source":"<string>","status":"<string>","target":"<string>"}}'
```

### SEO Backlink Competitors

Find the domains that share the most backlinks with a domain or URL, each with its authority rank and shared backlink count as normalized JSON.

**Price:** billed per result - \$28.80 per 1,000 requests base + \$0.05 per 1,000 results, capped at \$76.80 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [SEO Backlink Competitors pricing and uptime](https://getanyapi.com/api/seo/backlink-competitors) - live USD price, lane routing, and measured 30-day uptime. [Every Seo endpoint](https://getanyapi.com/api/seo).

`POST /v1/run/seo.backlink_competitors`

**Cost:** Up to $0.083712 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.083712 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/d602de84-7e87-4418-b929-75ef87d91d95

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `excludeLargeDomains` | boolean | No | Leave out very large sites (such as google.com or wikipedia.org) that share backlinks with almost everyone. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum number of competing domains to return. You are billed per returned result, so a lower limit costs less. |
| `mainDomainOnly` | boolean | No | Group results by registrable domain rather than listing subdomains separately. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `target` | string | Yes | Domain, subdomain, or full page URL to analyze. Send a domain without a protocol or leading www. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/seo.backlink_competitors","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","excludeLargeDomains":"<boolean>","ignoreSources":"<string>","limit":"<integer>","mainDomainOnly":"<boolean>","preferLatencyUnderMs":"<integer>","source":"<string>","target":"<string>"}}'
```

### SEO Backlinks

Get AnyAPI SEO backlinks for a domain or URL, each with the linking page, anchor text, dofollow flag, authority rank, spam score, and first and last seen dates as normalized JSON.

**Price:** billed per result - \$28.80 per 1,000 requests base + \$0.05 per 1,000 results, capped at \$76.80 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [SEO Backlinks pricing and uptime](https://getanyapi.com/api/seo/backlinks) - live USD price, lane routing, and measured 30-day uptime. [Every Seo endpoint](https://getanyapi.com/api/seo).

`POST /v1/run/seo.backlinks`

**Cost:** Up to $0.083712 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.083712 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/ce617c90-a3b0-4ab0-9af2-e74a4afa1f5d

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `includeSubdomains` | boolean | No | Count links pointing at the target's subdomains as well as the target itself. |
| `limit` | integer | No | Maximum number of backlinks to return. You are billed per returned result, so a lower limit costs less. |
| `mode` | string | No | as_is returns every backlink; one_per_domain keeps one backlink per linking domain; one_per_anchor keeps one per anchor text. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `status` | string | No | Return backlinks that are live now, ones that have been lost, or both. |
| `target` | string | Yes | Domain, subdomain, or full page URL to analyze. Send a domain without a protocol or leading www. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/seo.backlinks","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","includeSubdomains":"<boolean>","limit":"<integer>","mode":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","status":"<string>","target":"<string>"}}'
```

### SEO Backlinks Summary

Get AnyAPI SEO backlink profile totals for a domain or URL: backlinks, referring domains, authority rank, spam score, and broken links as normalized JSON.

**Price:** billed per result - \$28.85 per 1,000 requests base + \$0.00 per 1,000 results, capped at \$28.85 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [SEO Backlinks Summary pricing and uptime](https://getanyapi.com/api/seo/backlinks-summary) - live USD price, lane routing, and measured 30-day uptime. [Every Seo endpoint](https://getanyapi.com/api/seo).

`POST /v1/run/seo.backlinks_summary`

**Cost:** Up to $0.031447 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.031447 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/b9752817-7922-4553-aca6-bc3eb8c230df

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `includeSubdomains` | boolean | No | Count links pointing at the target's subdomains as well as the target itself. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `target` | string | Yes | Domain, subdomain, or full page URL to analyze. Send a domain without a protocol or leading www. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/seo.backlinks_summary","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","includeSubdomains":"<boolean>","preferLatencyUnderMs":"<integer>","source":"<string>","target":"<string>"}}'
```

### SEO Competitor Domains

Get AnyAPI SEO competitor domains for a target domain with shared keyword counts and organic metrics as normalized JSON.

**Price:** billed per result - \$28.64 per 1,000 requests base + \$0.16 per 1,000 results, capped at \$188.64 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [SEO Competitor Domains pricing and uptime](https://getanyapi.com/api/seo/competitors-domain) - live USD price, lane routing, and measured 30-day uptime. [Every Seo endpoint](https://getanyapi.com/api/seo).

`POST /v1/run/seo.competitors_domain`

**Cost:** Up to $0.205618 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.205618 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/a800df88-d5cd-4752-bdaa-8c7283c6154c

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `language` | string | No | Language code for SEO competitor metrics. |
| `limit` | integer | No | Maximum number of competitor domains to return. You are billed per returned result, so a lower limit costs less. |
| `location` | integer | No | Location code for SEO competitor metrics. The default is the United States. |
| `orderBy` | string | No | Sort order for the returned competitors: by shared keyword count (intersections), organic keyword count, organic traffic value (etv), or average position. Omit for the default order. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `target` | string | Yes | Domain to analyze, without a protocol or leading www. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/seo.competitors_domain","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","language":"<string>","limit":"<integer>","location":"<integer>","orderBy":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","target":"<string>"}}'
```

### SEO Domain Intersection

Get AnyAPI SEO keyword overlap for two domains with each domain's rankings, URLs, volume, CPC, and difficulty as normalized JSON.

**Price:** billed per result - \$28.64 per 1,000 requests base + \$0.16 per 1,000 results, capped at \$188.64 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [SEO Domain Intersection pricing and uptime](https://getanyapi.com/api/seo/domain-intersection) - live USD price, lane routing, and measured 30-day uptime. [Every Seo endpoint](https://getanyapi.com/api/seo).

`POST /v1/run/seo.domain_intersection`

**Cost:** Up to $0.205618 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.205618 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/8d8edc59-f533-479c-8afb-ac85e9f1dbf2

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `intersections` | boolean | No | When true (the default), return keywords both domains rank for (overlap). When false, return keywords the first domain ranks for that the second domain does NOT (the content-gap query); in that mode secondRank and secondUrl are absent. |
| `language` | string | No | Language code for SEO overlap metrics. |
| `limit` | integer | No | Maximum number of keywords to return. You are billed per returned result, so a lower limit costs less. |
| `location` | integer | No | Location code for SEO overlap metrics. The default is the United States. |
| `orderBy` | string | No | Sort order for the returned keywords: by search volume, cost per click, or keyword difficulty, ascending or descending. Omit for the default order. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `target1` | string | Yes | First domain to compare, without a protocol or leading www. |
| `target2` | string | Yes | Second domain to compare, without a protocol or leading www. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/seo.domain_intersection","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","intersections":"<boolean>","language":"<string>","limit":"<integer>","location":"<integer>","orderBy":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","target1":"<string>","target2":"<string>"}}'
```

### SEO Domain Pages

Get AnyAPI SEO pages of a domain with their backlink profile (rank, backlinks, referring domains) and on-page data (title, headings, word count, status, technologies) as normalized JSON.

**Price:** billed per result - \$28.80 per 1,000 requests base + \$0.05 per 1,000 results, capped at \$76.80 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [SEO Domain Pages pricing and uptime](https://getanyapi.com/api/seo/domain-pages) - live USD price, lane routing, and measured 30-day uptime. [Every Seo endpoint](https://getanyapi.com/api/seo).

`POST /v1/run/seo.domain_pages`

**Cost:** Up to $0.083712 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.083712 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/374634a8-b610-4682-811f-fd8e61857166

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `includeSubdomains` | boolean | No | Count links pointing at the target's subdomains as well as the target itself. |
| `limit` | integer | No | Maximum number of pages to return. You are billed per returned result, so a lower limit costs less. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `status` | string | No | Count backlinks that are live now, ones that have been lost, or both. |
| `target` | string | Yes | Domain or subdomain to list pages for, without a protocol or leading www. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/seo.domain_pages","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","includeSubdomains":"<boolean>","limit":"<integer>","preferLatencyUnderMs":"<integer>","source":"<string>","status":"<string>","target":"<string>"}}'
```

### SEO Domain Technologies

Detect the technology stack a website runs: CMS, analytics, marketing, hosting, and security, plus contacts and social profiles as normalized JSON.

**Price:** \$14.40 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [SEO Domain Technologies pricing and uptime](https://getanyapi.com/api/seo/domain-technologies) - live USD price, lane routing, and measured 30-day uptime. [Every Seo endpoint](https://getanyapi.com/api/seo).

`POST /v1/run/seo.domain_technologies`

**Cost:** Up to $0.015696 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.015696 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/d890ae71-176b-43ec-9aab-cac530337385

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `domain` | string | Yes | Domain to analyze, without a protocol or leading www. Billing is flat per request. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/seo.domain_technologies","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","domain":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### SEO Domains By Technology

Find websites running a given technology, category, or on-page term: domain, rank, detected stack, contacts, and social profiles as normalized JSON.

**Price:** billed per result - \$14.64 per 1,000 requests base + \$1.20 per 1,000 results, capped at \$134.64 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [SEO Domains By Technology pricing and uptime](https://getanyapi.com/api/seo/domains-by-technology) - live USD price, lane routing, and measured 30-day uptime. [Every Seo endpoint](https://getanyapi.com/api/seo).

`POST /v1/run/seo.domains_by_technology`

**Cost:** Up to $0.146758 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.146758 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/4a6bd6c2-de83-4a3e-bb1e-72ba0cb4e204

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `category` | string | No | Technology category to match, for example marketing_automation. Broader than technology: it returns every domain running anything in that category. |
| `cursor` | string | No | Pagination cursor from a previous response's nextCursor. Omit for the first page. |
| `group` | string | No | Top-level technology group to match, for example marketing or servers. The broadest selector. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `keyword` | string | No | On-page term to match in the site's HTML, for example highlevel. Use this to find sites running a product that the technology index does not detect by name. |
| `limit` | integer | No | Maximum number of domains to return in this response. You are billed per returned result, so a lower limit costs less. |
| `orderBy` | string | No | Sort order for the returned domains: by domain rank descending or ascending, by most recently crawled, or by country code. Omit for the default order. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `technology` | string | No | Exact technology name to match, for example Nginx or HubSpot. Only technologies present in the detection index are accepted; any other name is rejected with a 400 error and no charge, so use keyword instead when a product is not matched by name. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/seo.domains_by_technology","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","category":"<string>","cursor":"<string>","group":"<string>","ignoreSources":"<string>","keyword":"<string>","limit":"<integer>","orderBy":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","technology":"<string>"}}'
```

### SEO Keyword Difficulty

Get AnyAPI SEO keyword difficulty scores for one or more keywords as normalized JSON.

**Price:** billed per keyword - \$14.38 per 1,000 requests base + \$0.16 per 1,000 keywords, capped at \$174.38 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [SEO Keyword Difficulty pricing and uptime](https://getanyapi.com/api/seo/keyword-difficulty) - live USD price, lane routing, and measured 30-day uptime. [Every Seo endpoint](https://getanyapi.com/api/seo).

`POST /v1/run/seo.keyword_difficulty`

**Cost:** Up to $0.190074 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.190074 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/5f497e0d-c069-433e-8511-f4300beb4c20

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `keywords` | string | Yes | SEO keywords to score for organic ranking difficulty. |
| `language` | string | No | Language code for SEO keyword difficulty metrics. |
| `location` | integer | No | Location code for SEO keyword difficulty metrics. The default is the United States. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/seo.keyword_difficulty","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","keywords":"<string>","language":"<string>","location":"<integer>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### SEO Keyword Ideas

Find AnyAPI SEO keyword ideas from seed terms with volume, CPC, competition, difficulty, and intent as normalized JSON.

**Price:** billed per result - \$14.96 per 1,000 requests base + \$0.16 per 1,000 results, capped at \$174.96 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [SEO Keyword Ideas pricing and uptime](https://getanyapi.com/api/seo/keyword-ideas) - live USD price, lane routing, and measured 30-day uptime. [Every Seo endpoint](https://getanyapi.com/api/seo).

`POST /v1/run/seo.keyword_ideas`

**Cost:** Up to $0.190706 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.190706 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/bd61fbda-70c5-478a-82b6-8c8ce0f5fca5

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `closelyVariants` | boolean | No | When true, generate only close variants of the seed keywords; when false (the default), generate a broader set of related ideas. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `keywords` | string | Yes | Seed SEO keywords used to generate related keyword ideas. |
| `language` | string | No | Language code for SEO metrics. |
| `limit` | integer | No | Maximum number of keyword ideas to return. You are billed per returned result, so a lower limit costs less. |
| `location` | integer | No | Location code for SEO metrics. The default is the United States. |
| `orderBy` | string | No | Sort order for the returned ideas: by search volume, cost per click, or keyword difficulty, ascending or descending. Omit for the default order. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/seo.keyword_ideas","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","closelyVariants":"<boolean>","ignoreSources":"<string>","keywords":"<string>","language":"<string>","limit":"<integer>","location":"<integer>","orderBy":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### Spotify Search

Search Spotify for matching tracks, albums, artists, podcasts, and playlists by keyword.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Spotify Search pricing and uptime](https://getanyapi.com/api/spotify/search) - live USD price, lane routing, and measured 30-day uptime. [Every Spotify endpoint](https://getanyapi.com/api/spotify).

`POST /v1/run/spotify.search`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/3d5568d5-7599-45dc-ba99-a689904831a1

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Search term (e.g. "my first million"). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/spotify.search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","source":"<string>"}}'
```

### SEO Keyword Overview

Get AnyAPI SEO keyword metrics including search volume, CPC, competition, difficulty, and search intent as normalized JSON.

**Price:** billed per keyword - \$14.38 per 1,000 requests base + \$0.16 per 1,000 keywords, capped at \$126.38 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [SEO Keyword Overview pricing and uptime](https://getanyapi.com/api/seo/keyword-overview) - live USD price, lane routing, and measured 30-day uptime. [Every Seo endpoint](https://getanyapi.com/api/seo).

`POST /v1/run/seo.keyword_overview`

**Cost:** Up to $0.137754 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.137754 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/1c190f8f-9c08-47a3-824c-3b36f16922d3

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `keywords` | string | Yes | SEO keywords to analyze. |
| `language` | string | No | Language code for SEO metrics. |
| `location` | integer | No | Location code for SEO metrics. The default is the United States. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/seo.keyword_overview","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","keywords":"<string>","language":"<string>","location":"<integer>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### SEO Keyword Suggestions

Find AnyAPI SEO keyword suggestions from a seed term with volume, CPC, competition, difficulty, and intent as normalized JSON.

**Price:** billed per result - \$14.96 per 1,000 requests base + \$0.16 per 1,000 results, capped at \$174.96 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [SEO Keyword Suggestions pricing and uptime](https://getanyapi.com/api/seo/keyword-suggestions) - live USD price, lane routing, and measured 30-day uptime. [Every Seo endpoint](https://getanyapi.com/api/seo).

`POST /v1/run/seo.keyword_suggestions`

**Cost:** Up to $0.190706 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.190706 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/399af634-0562-495a-8a97-703fcdc00332

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `exactMatch` | boolean | No | When true, only return suggestions that contain the exact seed phrase; when false (the default), allow reordered and partial-match suggestions. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `keyword` | string | Yes | Seed SEO keyword used to generate keyword suggestions. |
| `language` | string | No | Language code for SEO metrics. |
| `limit` | integer | No | Maximum number of keyword suggestions to return. You are billed per returned result, so a lower limit costs less. |
| `location` | integer | No | Location code for SEO metrics. The default is the United States. |
| `orderBy` | string | No | Sort order for the returned suggestions: by search volume, cost per click, or keyword difficulty, ascending or descending. Omit for the default order. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/seo.keyword_suggestions","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","exactMatch":"<boolean>","ignoreSources":"<string>","keyword":"<string>","language":"<string>","limit":"<integer>","location":"<integer>","orderBy":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### SEO LLM Mentions

Find AI answers that mention a domain or keyword, from Google AI Overviews or ChatGPT, each with the question asked, the answer, its cited sources, and AI search volume as normalized JSON.

**Price:** billed per result - \$120.00 per 1,000 requests base + \$1.20 per 1,000 results, capped at \$1,320.00 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [SEO LLM Mentions pricing and uptime](https://getanyapi.com/api/seo/llm-mentions) - live USD price, lane routing, and measured 30-day uptime. [Every Seo endpoint](https://getanyapi.com/api/seo).

`POST /v1/run/seo.llm_mentions`

**Cost:** Up to $1.4388 per call. Response-based: the price is worked out from the usage reported in the response, never more than $1.4388 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/2738990f-4837-4619-a4c6-fec8af06c822

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `domain` | string | No | Domain whose mentions to find, without a protocol or leading www. Send domain or keyword, not both. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `keyword` | string | No | Brand name or phrase whose mentions to find. Send domain or keyword, not both. |
| `language` | string | No | Language code to restrict answers to, for example en. Omit for every language. |
| `limit` | integer | No | Maximum number of AI answers to return. You are billed per returned result, so a lower limit costs less. |
| `location` | integer | No | Location code to restrict answers to, for example 2840 for the United States. Omit for every location. |
| `platform` | string | No | AI surface to search: google for Google AI Overviews, chat_gpt for ChatGPT. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/seo.llm_mentions","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","domain":"<string>","ignoreSources":"<string>","keyword":"<string>","language":"<string>","limit":"<integer>","location":"<integer>","platform":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### SEO LLM Top Brands

Rank the brands ChatGPT names most often in answers about a keyword or domain, each with mention count, AI search volume, and the sources and categories behind them as normalized JSON.

**Price:** billed per result - \$120.00 per 1,000 requests base + \$1.20 per 1,000 results, capped at \$1,320.00 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [SEO LLM Top Brands pricing and uptime](https://getanyapi.com/api/seo/llm-top-brands) - live USD price, lane routing, and measured 30-day uptime. [Every Seo endpoint](https://getanyapi.com/api/seo).

`POST /v1/run/seo.llm_top_brands`

**Cost:** Up to $1.4388 per call. Response-based: the price is worked out from the usage reported in the response, never more than $1.4388 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/6989a522-356e-440d-849d-db58beaf174b

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `breakdownLimit` | integer | No | How many entries each breakdown list (cited domains, brands, locations, and so on) carries. |
| `domain` | string | No | Only count AI answers that mention or cite this domain, without a protocol or leading www. Send domain or keyword, not both. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `keyword` | string | No | Only count AI answers that contain this word or phrase. Send domain or keyword, not both. |
| `language` | string | No | Language code to restrict answers to, for example en. Omit for every language. |
| `limit` | integer | No | Maximum number of brands to return. You are billed per returned result, so a lower limit costs less. |
| `location` | integer | No | Location code to restrict answers to, for example 2840 for the United States. Omit for every location. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/seo.llm_top_brands","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","breakdownLimit":"<integer>","domain":"<string>","ignoreSources":"<string>","keyword":"<string>","language":"<string>","limit":"<integer>","location":"<integer>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### SEO LLM Top Domains

Rank the domains Google AI Overviews and ChatGPT cite most often in answers about a keyword or domain, each with mention count, AI search volume, and breakdowns by platform, location, and co-cited sources as normalized JSON.

**Price:** billed per result - \$120.00 per 1,000 requests base + \$1.20 per 1,000 results, capped at \$1,320.00 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [SEO LLM Top Domains pricing and uptime](https://getanyapi.com/api/seo/llm-top-domains) - live USD price, lane routing, and measured 30-day uptime. [Every Seo endpoint](https://getanyapi.com/api/seo).

`POST /v1/run/seo.llm_top_domains`

**Cost:** Up to $1.4388 per call. Response-based: the price is worked out from the usage reported in the response, never more than $1.4388 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/f52cee16-c32d-4e17-9887-d6bdeb41efa8

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `breakdownLimit` | integer | No | How many entries each breakdown list (cited domains, brands, locations, and so on) carries. |
| `domain` | string | No | Only count AI answers that mention or cite this domain, without a protocol or leading www. Send domain or keyword, not both. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `keyword` | string | No | Only count AI answers that contain this word or phrase. Send domain or keyword, not both. |
| `language` | string | No | Language code to restrict answers to, for example en. Omit for every language. |
| `limit` | integer | No | Maximum number of domains to return. You are billed per returned result, so a lower limit costs less. |
| `location` | integer | No | Location code to restrict answers to, for example 2840 for the United States. Omit for every location. |
| `platform` | string | No | AI surface to count: google for Google AI Overviews, chat_gpt for ChatGPT. Omit for both. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/seo.llm_top_domains","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","breakdownLimit":"<integer>","domain":"<string>","ignoreSources":"<string>","keyword":"<string>","language":"<string>","limit":"<integer>","location":"<integer>","platform":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### SEO LLM Top Pages

Rank the pages Google AI Overviews and ChatGPT cite most often in answers about a keyword or domain, each with mention count, AI search volume, and breakdowns by platform, location, and co-cited sources as normalized JSON.

**Price:** billed per result - \$120.00 per 1,000 requests base + \$1.20 per 1,000 results, capped at \$1,320.00 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [SEO LLM Top Pages pricing and uptime](https://getanyapi.com/api/seo/llm-top-pages) - live USD price, lane routing, and measured 30-day uptime. [Every Seo endpoint](https://getanyapi.com/api/seo).

`POST /v1/run/seo.llm_top_pages`

**Cost:** Up to $1.4388 per call. Response-based: the price is worked out from the usage reported in the response, never more than $1.4388 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/4132b098-fb39-4024-b5f2-0509394b6e3d

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `breakdownLimit` | integer | No | How many entries each breakdown list (cited domains, brands, locations, and so on) carries. |
| `domain` | string | No | Only count AI answers that mention or cite this domain, without a protocol or leading www. Send domain or keyword, not both. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `keyword` | string | No | Only count AI answers that contain this word or phrase. Send domain or keyword, not both. |
| `language` | string | No | Language code to restrict answers to, for example en. Omit for every language. |
| `limit` | integer | No | Maximum number of pages to return. You are billed per returned result, so a lower limit costs less. |
| `location` | integer | No | Location code to restrict answers to, for example 2840 for the United States. Omit for every location. |
| `platform` | string | No | AI surface to count: google for Google AI Overviews, chat_gpt for ChatGPT. Omit for both. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/seo.llm_top_pages","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","breakdownLimit":"<integer>","domain":"<string>","ignoreSources":"<string>","keyword":"<string>","language":"<string>","limit":"<integer>","location":"<integer>","platform":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### SEO Ranked Keywords

Get AnyAPI SEO ranked keywords for a domain with rankings, traffic estimates, volume, CPC, difficulty, and intent as normalized JSON. One call returns up to 1,000 keywords; use offset to page further.

**Price:** billed per result - \$14.96 per 1,000 requests base + \$0.16 per 1,000 results, capped at \$174.96 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [SEO Ranked Keywords pricing and uptime](https://getanyapi.com/api/seo/ranked-keywords) - live USD price, lane routing, and measured 30-day uptime. [Every Seo endpoint](https://getanyapi.com/api/seo).

`POST /v1/run/seo.ranked_keywords`

**Cost:** Up to $0.190706 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.190706 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/68d1d1d4-6076-4d87-bc04-6e7c4590601e

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `language` | string | No | Language code for SEO ranking metrics. |
| `limit` | integer | No | Maximum number of ranked keywords to return. 1,000 is the per-call maximum; use offset to fetch more. You are billed per returned result, so a lower limit costs less. |
| `location` | integer | No | Location code for SEO ranking metrics. The default is the United States. |
| `offset` | integer | No | Number of ranked keywords to skip in the chosen sort order. To fetch the next page, set offset to the previous offset plus limit, and keep the same orderBy, location, and language across pages. You are billed only for the keywords returned. |
| `orderBy` | string | No | Sort order for the returned ranked keywords: by SERP position (ascending for best rankings first), search volume, or estimated traffic value (etv). Omit for the default order. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `target` | string | Yes | Domain to analyze, without a protocol or leading www. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/seo.ranked_keywords","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","language":"<string>","limit":"<integer>","location":"<integer>","offset":"<integer>","orderBy":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","target":"<string>"}}'
```

### SEO Referring Domains

Get AnyAPI SEO referring domains for a domain or URL, each with its backlink count, authority rank, spam score, and first seen date as normalized JSON.

**Price:** billed per result - \$28.80 per 1,000 requests base + \$0.05 per 1,000 results, capped at \$76.80 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [SEO Referring Domains pricing and uptime](https://getanyapi.com/api/seo/referring-domains) - live USD price, lane routing, and measured 30-day uptime. [Every Seo endpoint](https://getanyapi.com/api/seo).

`POST /v1/run/seo.referring_domains`

**Cost:** Up to $0.083712 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.083712 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/626be6c6-0dc2-4826-a982-4759356eedd7

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `includeSubdomains` | boolean | No | Count links pointing at the target's subdomains as well as the target itself. |
| `limit` | integer | No | Maximum number of referring domains to return. You are billed per returned result, so a lower limit costs less. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `target` | string | Yes | Domain, subdomain, or full page URL to analyze. Send a domain without a protocol or leading www. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/seo.referring_domains","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","includeSubdomains":"<boolean>","limit":"<integer>","preferLatencyUnderMs":"<integer>","source":"<string>","target":"<string>"}}'
```

### SEO Related Keywords

Find AnyAPI SEO related keywords from a seed term with volume, CPC, competition, difficulty, and intent as normalized JSON.

**Price:** billed per result - \$14.96 per 1,000 requests base + \$0.16 per 1,000 results, capped at \$174.96 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [SEO Related Keywords pricing and uptime](https://getanyapi.com/api/seo/related-keywords) - live USD price, lane routing, and measured 30-day uptime. [Every Seo endpoint](https://getanyapi.com/api/seo).

`POST /v1/run/seo.related_keywords`

**Cost:** Up to $0.190706 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.190706 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/51b2d3bc-1641-4f4c-be94-804f4d05148e

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `depth` | integer | No | Depth of the related-keyword expansion (0-4). Higher depth explores a broader keyword tree; the number of returned results, and therefore the price, is still capped by limit. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `keyword` | string | Yes | Seed SEO keyword used to find related keywords. |
| `language` | string | No | Language code for SEO metrics. |
| `limit` | integer | No | Maximum number of related keywords to return. You are billed per returned result, so a lower limit costs less. |
| `location` | integer | No | Location code for SEO metrics. The default is the United States. |
| `orderBy` | string | No | Sort order for the returned related keywords: by search volume, cost per click, or keyword difficulty, ascending or descending. Omit for the default order. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/seo.related_keywords","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","depth":"<integer>","ignoreSources":"<string>","keyword":"<string>","language":"<string>","limit":"<integer>","location":"<integer>","orderBy":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### Spotify Track

Fetch a Spotify track's play count, popularity, duration, and album details by track URL or ID.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Spotify Track pricing and uptime](https://getanyapi.com/api/spotify/track) - live USD price, lane routing, and measured 30-day uptime. [Every Spotify endpoint](https://getanyapi.com/api/spotify).

`POST /v1/run/spotify.track`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/df8b3743-dfd1-46b5-b84c-23424f61efe6

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `id` | string | No | Spotify track ID (alternative to url). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | No | Spotify track URL (e.g. https://open.spotify.com/track/4cOdK2wGLETKBW3PvgPWqT). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/spotify.track","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","id":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### SEO Search Intent

Classify AnyAPI SEO keyword search intent as normalized JSON.

**Price:** billed per keyword - \$14.38 per 1,000 requests base + \$0.16 per 1,000 keywords, capped at \$174.38 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [SEO Search Intent pricing and uptime](https://getanyapi.com/api/seo/search-intent) - live USD price, lane routing, and measured 30-day uptime. [Every Seo endpoint](https://getanyapi.com/api/seo).

`POST /v1/run/seo.search_intent`

**Cost:** Up to $0.190074 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.190074 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/9e59ba6f-e8fa-4c4c-9754-4b259ad78efa

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `keywords` | string | Yes | SEO keywords to classify by search intent. |
| `language` | string | No | Language code for search intent classification. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/seo.search_intent","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","keywords":"<string>","language":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### SEO Search Volume

Get AnyAPI SEO keyword search volume, CPC, competition, bid estimates, and monthly history as normalized JSON.

**Price:** billed per result - \$108.00 per 1,000 requests base + \$0.00 per 1,000 results, capped at \$108.00 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [SEO Search Volume pricing and uptime](https://getanyapi.com/api/seo/search-volume) - live USD price, lane routing, and measured 30-day uptime. [Every Seo endpoint](https://getanyapi.com/api/seo).

`POST /v1/run/seo.search_volume`

**Cost:** Up to $0.11772 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.11772 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/8e4c63a2-0764-442a-8948-514ff23b8882

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `dateFrom` | string | No | Start of the historical monthly-searches window, formatted YYYY-MM-DD. Cannot be more than four years before today. Omit for the default trailing window. |
| `dateTo` | string | No | End of the historical monthly-searches window, formatted YYYY-MM-DD. Omit for the default trailing window. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `keywords` | string | Yes | SEO keyword phrases to retrieve search-volume metrics for. |
| `language` | string | No | Language code for SEO search-volume metrics. |
| `location` | integer | No | Location code for SEO search-volume metrics. The default is the United States. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `searchPartners` | boolean | No | When true, include Google search-partner network volume in the reported numbers; when false (the default), count Google search only. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/seo.search_volume","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","dateFrom":"<string>","dateTo":"<string>","ignoreSources":"<string>","keywords":"<string>","language":"<string>","location":"<integer>","preferLatencyUnderMs":"<integer>","searchPartners":"<boolean>","source":"<string>"}}'
```

### SEO Top Pages

Get AnyAPI SEO top pages of a domain by organic search, each with ranking keyword counts, estimated traffic and its ad value, and position distribution as normalized JSON.

**Price:** billed per result - \$14.40 per 1,000 requests base + \$0.15 per 1,000 results, capped at \$158.40 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [SEO Top Pages pricing and uptime](https://getanyapi.com/api/seo/top-pages) - live USD price, lane routing, and measured 30-day uptime. [Every Seo endpoint](https://getanyapi.com/api/seo).

`POST /v1/run/seo.top_pages`

**Cost:** Up to $0.172656 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.172656 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/d00dc11f-46a9-4ab5-bd3e-7a4d99aff3fc

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `language` | string | No | Language code for search metrics. |
| `limit` | integer | No | Maximum number of pages to return. You are billed per returned result, so a lower limit costs less. |
| `location` | integer | No | Location code for search metrics. The default is the United States. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `status` | string | No | Count rankings the page holds now, rankings it has lost, or both. |
| `target` | string | Yes | Domain to analyze, without a protocol or leading www. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/seo.top_pages","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","language":"<string>","limit":"<integer>","location":"<integer>","preferLatencyUnderMs":"<integer>","source":"<string>","status":"<string>","target":"<string>"}}'
```

### Shopify Product

Look up one product on any public Shopify store by its handle or product page URL and get title, vendor, type, tags, description, price range, sale price, stock, images, options and every variant's SKU, price and stock in one normalized response.

**Price:** \$0.85 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Shopify Product pricing and uptime](https://getanyapi.com/api/shopify/product) - live USD price, lane routing, and measured 30-day uptime. [Every Shopify endpoint](https://getanyapi.com/api/shopify).

`POST /v1/run/shopify.product`

**Cost:** Up to $0.000927 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.000927 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/966c4c6a-acf2-426a-8741-257e20706f7b

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `product` | string | Yes | Product handle, the slug after /products/ in the product URL, e.g. mens-strider; the full product page URL also works. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `store` | string | Yes | Domain or URL of a public Shopify store, e.g. allbirds.com or https://kith.com. A store on its own domain is addressed by that domain. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/shopify.product","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","product":"<string>","source":"<string>","store":"<string>"}}'
```

### Shopify Store Products

List the products of any public Shopify store by its domain, a page at a time, with title, vendor, type, tags, price range, sale price, stock, images, options and every variant's SKU, price and stock. Filter by vendor, type, tag, title, SKU, price, sale, stock or recent arrivals. A domain that is not a public Shopify store comes back not found.

**Price:** \$0.85 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Shopify Store Products pricing and uptime](https://getanyapi.com/api/shopify/products) - live USD price, lane routing, and measured 30-day uptime. [Every Shopify endpoint](https://getanyapi.com/api/shopify).

`POST /v1/run/shopify.products`

**Cost:** Up to $0.000927 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.000927 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/79ab26e8-dc2a-49e9-b9a9-2a645d24c7f1

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Products the store is asked for per page (1-250, default 50). The filters below are applied to that page, so a filtered page can hold fewer, even none while hasMore is true. |
| `maxPrice` | number | No | Only products priced at or below this, in the store's currency. |
| `minPrice` | number | No | Only products priced at or above this, in the store's currency. |
| `onlyInStock` | boolean | No | Only products with at least one variant in stock. |
| `onlyOnSale` | boolean | No | Only products with at least one discounted variant. |
| `page` | integer | No | 1-based page of the store's product list. Each page is billed as one request. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `productType` | string | No | Only products whose product type contains this text, e.g. "Shoes". |
| `publishedWithinDays` | integer | No | Only products published to the store within the last this many days. |
| `skuContains` | string | No | Only products with a variant whose SKU code contains this text. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `store` | string | Yes | Domain or URL of a public Shopify store, e.g. allbirds.com or https://kith.com. A store on its own domain is addressed by that domain. |
| `tags` | string | No | Only products carrying at least one of these tags. |
| `titleContains` | string | No | Only products whose title contains this text. |
| `vendor` | string | No | Only products whose vendor (brand) contains this text. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/shopify.products","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","limit":"<integer>","maxPrice":"<number>","minPrice":"<number>","onlyInStock":"<boolean>","onlyOnSale":"<boolean>","page":"<integer>","preferLatencyUnderMs":"<integer>","productType":"<string>","publishedWithinDays":"<integer>","skuContains":"<string>","source":"<string>","store":"<string>","tags":"<string>","titleContains":"<string>","vendor":"<string>"}}'
```

### Shopify Store Search

Search one public Shopify store's products by keyword with the store's own search and get its top matches with title, vendor, type, tags, price range, sale price, stock and images. A domain that is not a public Shopify store comes back not found.

**Price:** \$0.85 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Shopify Store Search pricing and uptime](https://getanyapi.com/api/shopify/search) - live USD price, lane routing, and measured 30-day uptime. [Every Shopify endpoint](https://getanyapi.com/api/shopify).

`POST /v1/run/shopify.search`

**Cost:** Up to $0.000927 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.000927 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/afb5235f-ecbd-4ec4-85ce-b842d0275255

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Search keywords, e.g. "wool" or "hoodie". |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `store` | string | Yes | Domain or URL of a public Shopify store, e.g. allbirds.com or https://kith.com. A store on its own domain is addressed by that domain. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/shopify.search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","source":"<string>","store":"<string>"}}'
```

### Shopify Store Profile

Look up any public Shopify store by its domain and get its name, description, currency, country and city, the countries it ships to, its published product and collection counts and its social links in one normalized response. A domain that is not a public Shopify store comes back not found.

**Price:** \$0.85 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Shopify Store Profile pricing and uptime](https://getanyapi.com/api/shopify/store) - live USD price, lane routing, and measured 30-day uptime. [Every Shopify endpoint](https://getanyapi.com/api/shopify).

`POST /v1/run/shopify.store`

**Cost:** Up to $0.000927 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.000927 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/f14d59b7-c7ff-4062-aa1d-4791ab4ba8a1

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `store` | string | Yes | Domain or URL of a public Shopify store, e.g. allbirds.com or https://kith.com. A store on its own domain is addressed by that domain. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/shopify.store","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","store":"<string>"}}'
```

### Similarweb Website Traffic

Get the Similarweb traffic overview for any website: estimated monthly visits and a three-month history, global, country, and category rank, bounce rate, pages per visit, visit duration, traffic sources including AI chatbots, top countries, and top search keywords - as normalized JSON.

**Price:** billed per result - \$0.02 per 1,000 requests base + \$1.65 per 1,000 results, capped at \$1.67 per 1,000 requests.

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Similarweb Website Traffic pricing and uptime](https://getanyapi.com/api/similarweb/overview) - live USD price, lane routing, and measured 30-day uptime. [Every Similarweb endpoint](https://getanyapi.com/api/similarweb).

`POST /v1/run/similarweb.overview`

**Cost:** Up to $0.002278 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.002278 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/677a72a1-7a42-452b-bce1-be1f3c53b614

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `domain` | string | Yes | The website's domain, without a scheme or path (e.g. stripe.com). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/similarweb.overview","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","domain":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### Similarweb Similar Sites

Find the websites Similarweb ranks as most similar to any website: up to 20 competitor and alternative sites in similarity order, each with its similarity score, category, top-country rank, estimated monthly visits, and description - as normalized JSON.

**Price:** billed per result - \$0.02 per 1,000 requests base + \$1.65 per 1,000 results, capped at \$1.67 per 1,000 requests.

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Similarweb Similar Sites pricing and uptime](https://getanyapi.com/api/similarweb/similar-sites) - live USD price, lane routing, and measured 30-day uptime. [Every Similarweb endpoint](https://getanyapi.com/api/similarweb).

`POST /v1/run/similarweb.similar_sites`

**Cost:** Up to $0.002278 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.002278 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/968ab5fe-4a7f-4d8f-aaba-7a2c2a97914e

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `domain` | string | Yes | The website's domain, without a scheme or path (e.g. stripe.com). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/similarweb.similar_sites","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","domain":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### Slickdeals Deal

Fetch one Slickdeals deal by URL and get title, price, list price, store, coupon code, score, views, comments, and description in one normalized response.

**Price:** \$2.13 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Slickdeals Deal pricing and uptime](https://getanyapi.com/api/slickdeals/deal) - live USD price, lane routing, and measured 30-day uptime. [Every Slickdeals endpoint](https://getanyapi.com/api/slickdeals).

`POST /v1/run/slickdeals.deal`

**Cost:** Up to $0.002322 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.002322 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/cc660b42-a577-4450-a704-0142e9b4e2e9

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Slickdeals deal page URL, e.g. https://slickdeals.net/f/20177112-lg-55-c6-series-oled-evo-ai-4k-smart-webos-tv-2026-best-buy-amazon-999-99. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/slickdeals.deal","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### Slickdeals Search

Search Slickdeals deals by keyword with optional sort, price, discount, and page filters and get title, price, list price, store, score, and comment count for each deal in one normalized response.

**Price:** \$2.13 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Slickdeals Search pricing and uptime](https://getanyapi.com/api/slickdeals/search) - live USD price, lane routing, and measured 30-day uptime. [Every Slickdeals endpoint](https://getanyapi.com/api/slickdeals).

`POST /v1/run/slickdeals.search`

**Cost:** Up to $0.002322 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.002322 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/b1d4cec1-f0dd-439a-925d-ca01d1cb8aad

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `hideExpired` | boolean | No | Optional; true leaves out deals the community marked expired. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `maxPrice` | number | No | Optional maximum deal price in USD; deals without a numeric price are left out. |
| `minDiscount` | integer | No | Optional; keep only deals at least this many percent off the list price, e.g. 50. |
| `minPrice` | number | No | Optional minimum deal price in USD; deals without a numeric price are left out. |
| `page` | integer | No | 1-based page of 40 deals; Slickdeals stops at page 25. Each page is billed as one request. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Search keywords, e.g. "airpods" or "laptop". |
| `sort` | string | No | Result order; omit for Slickdeals' relevance order (e.g. new for the most recently posted deals first). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/slickdeals.search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","hideExpired":"<boolean>","ignoreSources":"<string>","maxPrice":"<number>","minDiscount":"<integer>","minPrice":"<number>","page":"<integer>","preferLatencyUnderMs":"<integer>","query":"<string>","sort":"<string>","source":"<string>"}}'
```

### Snapchat Profile

Fetch a Snapchat user's public profile by username: display name, bio, subscriber count, and recent public content.

**Price:** \$1.10 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Snapchat Profile pricing and uptime](https://getanyapi.com/api/snapchat/profile) - live USD price, lane routing, and measured 30-day uptime. [Every Snapchat endpoint](https://getanyapi.com/api/snapchat).

`POST /v1/run/snapchat.profile`

**Cost:** Up to $0.003597 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003597 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/7ba581d6-3513-4c48-aeeb-38d836d0218f

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `username` | string | Yes | The Snapchat username or profile URL to look up (e.g. fcbarcelona or https://www.snapchat.com/add/fcbarcelona). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/snapchat.profile","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","username":"<string>"}}'
```

### Substack Posts

Pull posts from any Substack publication by its URL, or pass a single post URL (…/p/slug) to fetch just that one article. Returns title, subtitle, publish date, paywall status, word count, engagement (reactions, comments, restacks), author profile, publication details, the full article body as text, HTML and Markdown, and optional comment threads.

**Price:** billed per result - \$0.39 per 1,000 requests base + \$0.44 per 1,000 results, capped at \$44.40 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Substack Posts pricing and uptime](https://getanyapi.com/api/substack/posts) - live USD price, lane routing, and measured 30-day uptime. [Every Substack endpoint](https://getanyapi.com/api/substack).

`POST /v1/run/substack.posts`

**Cost:** Up to $0.28885 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.28885 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/3848e020-7107-467e-8588-7e0213227e55

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `contentType` | string | No | Restrict to a single post type, or 'all' (e.g. newsletter). |
| `endDate` | string | No | Only return posts published on or before this date, format YYYY-MM-DD (e.g. 2024-12-31). Applied within the most recent 'limit' posts scanned. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `includeComments` | boolean | No | Include public comment threads and their direct replies on each post (e.g. true). |
| `includeContent` | boolean | No | Include the full article body as text, HTML and Markdown. Set false for metadata only, which is faster (e.g. false). |
| `limit` | integer | No | Maximum number of recent posts to return when given a publication URL (1-100, default 25); ignored for a single post URL, which always returns that one post. You are billed per post returned, so a lower limit costs less. |
| `maxComments` | integer | No | Maximum comments collected per post when 'includeComments' is true (0-500, default 20). Costs nothing extra (e.g. 50). |
| `minComments` | integer | No | Only return posts with at least this many comments (e.g. 10). |
| `minReactions` | integer | No | Only return posts with at least this many reactions (e.g. 100). |
| `minWordCount` | integer | No | Only return posts with at least this many words, which filters out short notes and announcements (e.g. 1000). |
| `onlyFree` | boolean | No | Return only free (non-paywalled) posts (e.g. true). |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `startDate` | string | No | Only return posts published on or after this date, format YYYY-MM-DD (e.g. 2024-01-01). Applied within the most recent 'limit' posts scanned, so raise 'limit' to reach older date ranges. |
| `url` | string | Yes | Either a Substack publication URL / custom domain to fetch its recent posts (e.g. https://www.astralcodexten.com), OR a single post URL to fetch just that one article with full content (e.g. https://www.astralcodexten.com/p/your-book-review). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/substack.posts","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","contentType":"<string>","endDate":"<string>","ignoreSources":"<string>","includeComments":"<boolean>","includeContent":"<boolean>","limit":"<integer>","maxComments":"<integer>","minComments":"<integer>","minReactions":"<integer>","minWordCount":"<integer>","onlyFree":"<boolean>","preferLatencyUnderMs":"<integer>","source":"<string>","startDate":"<string>","url":"<string>"}}'
```

### Social Profile Finder

Find a person's or brand's profiles across major social networks from a single name, returned as normalized JSON.

**Price:** billed per result - \$1.10 per 1,000 requests base + \$2.20 per 1,000 results, capped at \$23.10 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Social Profile Finder pricing and uptime](https://getanyapi.com/api/social/finder) - live USD price, lane routing, and measured 30-day uptime. [Every Social endpoint](https://getanyapi.com/api/social).

`POST /v1/run/social.finder`

**Cost:** Up to $0.025179 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.025179 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/a5e4f2d8-9395-475b-95b4-db1027a81979

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum number of results to return (1-10, default 10). You are billed per result returned, so a lower limit costs less. |
| `name` | string | Yes | The profile name or handle to search for across social networks (e.g. johndoe). |
| `platform` | string | No | Limit the search to one network: askfm, discord, facebook, github, instagram, linkedin, medium, pinterest, steam, threads, tiktok, twitch, or youtube (e.g. instagram); all networks are searched when omitted. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/social.finder","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","limit":"<integer>","name":"<string>","platform":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### Spotify Album

Fetch a Spotify album's tracklist, play counts, label, and release details by album URL or ID.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Spotify Album pricing and uptime](https://getanyapi.com/api/spotify/album) - live USD price, lane routing, and measured 30-day uptime. [Every Spotify endpoint](https://getanyapi.com/api/spotify).

`POST /v1/run/spotify.album`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/b31d2dc5-f50c-4774-a689-cc7f97eb765d

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `id` | string | No | Spotify album ID (alternative to url). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | No | Spotify album URL (e.g. https://open.spotify.com/album/0pgrg7phBbnwGJ2HBEl9EG). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/spotify.album","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","id":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### Spotify Artist

Fetch a Spotify artist's discography (albums, singles, top tracks) and metadata by artist URL or ID.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Spotify Artist pricing and uptime](https://getanyapi.com/api/spotify/artist) - live USD price, lane routing, and measured 30-day uptime. [Every Spotify endpoint](https://getanyapi.com/api/spotify).

`POST /v1/run/spotify.artist`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/b0a28098-4218-4fbe-abfb-970a6c5fb843

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `id` | string | No | Spotify artist ID (alternative to url). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | No | Spotify artist URL (e.g. https://open.spotify.com/artist/3DiDSECUqqY1AuBP8qtaIa). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/spotify.artist","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","id":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### Spotify Play Count

Fetch stream counts and stats for a Spotify track, album, or artist URL.

**Price:** billed per result - \$3.30 per 1,000 results, capped at \$3.30 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Spotify Play Count pricing and uptime](https://getanyapi.com/api/spotify/play-count) - live USD price, lane routing, and measured 30-day uptime. [Every Spotify endpoint](https://getanyapi.com/api/spotify).

`POST /v1/run/spotify.play_count`

**Cost:** Up to $0.002398 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.002398 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/7bb36248-9838-47c6-96f0-22f256d79511

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Spotify track, album, or artist URL to fetch stream counts for (e.g. https://open.spotify.com/track/3n3Ppam7vgaVa1iaRUc9Lp). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/spotify.play_count","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### Spotify Podcast

Fetch a Spotify podcast show's name, publisher, description, rating, and topics by show URL or ID.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Spotify Podcast pricing and uptime](https://getanyapi.com/api/spotify/podcast) - live USD price, lane routing, and measured 30-day uptime. [Every Spotify endpoint](https://getanyapi.com/api/spotify).

`POST /v1/run/spotify.podcast`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/bf6040bf-ca47-4bc8-abb1-5800722ad497

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `id` | string | No | Spotify podcast show ID (alternative to url). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | No | Spotify podcast show URL (e.g. https://open.spotify.com/show/3mliji9352UAk3XnWElnDV). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/spotify.podcast","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","id":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### Target Product

Fetch a Target.com product by URL and get title, price, brand, rating, description, and images in one normalized response.

**Price:** \$0.85 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Target Product pricing and uptime](https://getanyapi.com/api/target/product) - live USD price, lane routing, and measured 30-day uptime. [Every Target endpoint](https://getanyapi.com/api/target).

`POST /v1/run/target.product`

**Cost:** Up to $0.003477 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003477 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/f190b6f6-3527-463c-9ac7-15412df83dcd

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `availability`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a pr |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Target product page URL; the TCIN after /A- identifies the product (e.g. https://www.target.com/p/-/A-91863920). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/target.product","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>","url":"<string>"}}'
```

### Telegram Channel

Get a public Telegram channel by username: name, bio, photo, verified badge, exact subscriber count, and how many photos, videos, files and links it has posted.

**Price:** \$1.10 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Telegram Channel pricing and uptime](https://getanyapi.com/api/telegram/channel) - live USD price, lane routing, and measured 30-day uptime. [Every Telegram endpoint](https://getanyapi.com/api/telegram).

`POST /v1/run/telegram.channel`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/578abe58-019a-4b0a-8383-a4d14f57db30

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `handle` | string | Yes | Public Telegram channel username, with or without the @ (e.g. "telegram"), or its t.me link. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `photoCount`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a chan |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/telegram.channel","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","handle":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>"}}'
```

### Telegram Channel Posts

Get a public Telegram channel's posts by username, about 20 per page with a cursor for older pages: text, posting time, views, photo and video links, and reactions.

**Price:** \$1.10 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Telegram Channel Posts pricing and uptime](https://getanyapi.com/api/telegram/channel-posts) - live USD price, lane routing, and measured 30-day uptime. [Every Telegram endpoint](https://getanyapi.com/api/telegram).

`POST /v1/run/telegram.channel_posts`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/cd8b6a96-168d-421b-9986-0a89d8f8a873

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Opaque pagination cursor from a previous response's nextCursor, for older posts. Omit for the newest page; a page holds about 20 posts. |
| `handle` | string | Yes | Public Telegram channel username, with or without the @ (e.g. "telegram"), or its t.me link. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `linkPreviewUrl` or `edited`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/telegram.channel_posts","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","handle":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>"}}'
```

### Telegram Post

Get one public Telegram channel post by its t.me link: text, posting time, views, photo and video links, and reactions.

**Price:** \$1.10 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Telegram Post pricing and uptime](https://getanyapi.com/api/telegram/post) - live USD price, lane routing, and measured 30-day uptime. [Every Telegram endpoint](https://getanyapi.com/api/telegram).

`POST /v1/run/telegram.post`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/990c80d2-f660-449a-99d3-0da0f5dd7759

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `linkPreviewUrl` or `edited`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Link to one public channel post, e.g. https://t.me/telegram/460 (t.me/s/ links work too). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/telegram.post","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>","url":"<string>"}}'
```

### Threads Post

Fetch a single Threads post by URL: text, author, engagement counts, and timestamp.

**Price:** \$1.10 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Threads Post pricing and uptime](https://getanyapi.com/api/threads/post) - live USD price, lane routing, and measured 30-day uptime. [Every Threads endpoint](https://getanyapi.com/api/threads).

`POST /v1/run/threads.post`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/6ceb1e75-9a80-4cfa-adb7-b7efb95df314

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | The full URL of the Threads post to fetch (e.g. https://www.threads.com/@zuck/post/C8yKXdRxKqK). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/threads.post","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### Threads Profile

Fetch a Threads user's public profile (bio, follower count, verification, profile picture) by username.

**Price:** \$1.10 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Threads Profile pricing and uptime](https://getanyapi.com/api/threads/profile) - live USD price, lane routing, and measured 30-day uptime. [Every Threads endpoint](https://getanyapi.com/api/threads).

`POST /v1/run/threads.profile`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/0b54e5af-f4e2-42a9-a7b0-43a2ee101ed5

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `username` | string | Yes | The Threads username to look up, without the @ prefix (e.g. zuck). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/threads.profile","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","username":"<string>"}}'
```

### Threads Search

Search public Threads posts by keyword or hashtag and get normalized post records: text, author, and engagement.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Threads Search pricing and uptime](https://getanyapi.com/api/threads/search) - live USD price, lane routing, and measured 30-day uptime. [Every Threads endpoint](https://getanyapi.com/api/threads).

`POST /v1/run/threads.search`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/baf9016f-ecf1-47a9-9c48-929607b4a7f8

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `endDate` | string | No | Only return posts published on or before this date, format YYYY-MM-DD (e.g. 2026-08-07). Threads pages backwards in time from here, so narrowing this is how you walk older results. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Keyword or hashtag to search public Threads posts for; the # prefix is optional (e.g. AI agents). Threads matches text in posts, so search a brand or topic rather than a URL - a query that is only a domain is searched by its name (wander.com is searched as wander). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `startDate` | string | No | Only return posts published on or after this date, format YYYY-MM-DD (e.g. 2026-08-01). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/threads.search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","endDate":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","source":"<string>","startDate":"<string>"}}'
```

### Threads User Search

Search Threads users by name or username and get normalized profile records: username, full name, verification, and picture.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Threads User Search pricing and uptime](https://getanyapi.com/api/threads/search-users) - live USD price, lane routing, and measured 30-day uptime. [Every Threads endpoint](https://getanyapi.com/api/threads).

`POST /v1/run/threads.search_users`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/cffa5156-bf16-4eb1-b4d1-a719c1b58613

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | The name or username to search Threads users for. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/threads.search_users","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","source":"<string>"}}'
```

### Threads User Posts

List a Threads user's recent public posts by username: text, engagement counts, and post URLs.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Threads User Posts pricing and uptime](https://getanyapi.com/api/threads/user-posts) - live USD price, lane routing, and measured 30-day uptime. [Every Threads endpoint](https://getanyapi.com/api/threads).

`POST /v1/run/threads.user_posts`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/693d2593-2283-453c-bdb8-50d03c8e106c

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `handle` | string | Yes | The Threads username to list posts for, without the @ prefix. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/threads.user_posts","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","handle":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### TikTok Ad Library Ad

Fetch full details for a single TikTok ad (brand, title, spend, CTR, objectives, landing page, and video info).

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [TikTok Ad Library Ad pricing and uptime](https://getanyapi.com/api/tiktok/ad-library-ad) - live USD price, lane routing, and measured 30-day uptime. [Every TikTok endpoint](https://getanyapi.com/api/tiktok).

`POST /v1/run/tiktok.ad_library_ad`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/ce744469-e51c-4455-9141-a3d37720572b

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `adId` | string | Yes | TikTok Top Ads material/ad ID, or a Top Ads detail URL (e.g. 7648493525660270600). |
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/tiktok.ad_library_ad","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"adId":"<string>","allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### TikTok Ad Library Search

Search TikTok's public Ads Library by keyword or advertiser (advertiser, title, audience band, run dates, library link, and video).

**Price:** \$0.80 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [TikTok Ad Library Search pricing and uptime](https://getanyapi.com/api/tiktok/ad-library-search) - live USD price, lane routing, and measured 30-day uptime. [Every TikTok endpoint](https://getanyapi.com/api/tiktok).

`POST /v1/run/tiktok.ad_library_search`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/a2af92ec-c8dd-470e-9165-ed1eff8d12b5

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `advertiserName` | string | No | Advertiser name to list ads for (e.g. Spotify). Provide advertiserName or query, never both. |
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Opaque cursor from a previous response's nextCursor. Omit it for the first page. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | No | Keyword to search ad titles and content (e.g. spotify). Provide query or advertiserName, never both. |
| `region` | string | No | Two-letter region code for TikTok's Commercial Content Library, such as DE, FR, GB or IT. Each region holds a different set of ads. Omit it to take the library's own default region, DE. Coverage is the EU and EEA; a non-EU code such as US is not served. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/tiktok.ad_library_search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"advertiserName":"<string>","allowFallbacks":"<boolean>","cursor":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","region":"<string>","source":"<string>"}}'
```

### TikTok Audience Demographics

Get the audience country breakdown (follower count and share per country) for a TikTok creator by handle.

**Price:** \$18.00 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [TikTok Audience Demographics pricing and uptime](https://getanyapi.com/api/tiktok/audience-demographics) - live USD price, lane routing, and measured 30-day uptime. [Every TikTok endpoint](https://getanyapi.com/api/tiktok).

`POST /v1/run/tiktok.audience_demographics`

**Cost:** Up to $0.031196 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.031196 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/4ba2d76b-5baf-4703-898b-0ce5c6efcd16

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `handle` | string | Yes | TikTok username without the leading @ (e.g. "shakira"). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/tiktok.audience_demographics","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","handle":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### TikTok Comment Replies

List the replies to a TikTok comment with cursor pagination (text, author, likes).

**Price:** \$0.60 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 4 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [TikTok Comment Replies pricing and uptime](https://getanyapi.com/api/tiktok/comment-replies) - live USD price, lane routing, and measured 30-day uptime. [Every TikTok endpoint](https://getanyapi.com/api/tiktok).

`POST /v1/run/tiktok.comment_replies`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/65d630d4-619d-41ec-993b-2fe9e922dced

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `commentId` | string | Yes | TikTok comment ID (the comment's cid from the comments endpoint). |
| `cursor` | string | No | Pagination cursor from a previous response. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `authorUserId`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a re |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | TikTok video URL the comment belongs to, on tiktok.com: a video or photo post (https://www.tiktok.com/@<user>/video/<id> or /photo/<id>) or a vm.tiktok.com, vt.tiktok.com or tiktok.com/t/ share link. A /video/ or /photo/ link without the post's numeric id, a profile link (https://www.tiktok.com/@<user>), a /@<user>/<id> link without /video/, a video file link (tiktokcdn.com) or a link to any other site is refused as invalid input, with no charge. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/tiktok.comment_replies","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","commentId":"<string>","cursor":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>","url":"<string>"}}'
```

### TikTok Followers

List the followers of a TikTok account by username, returning each follower's profile basics.

**Price:** \$0.80 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [TikTok Followers pricing and uptime](https://getanyapi.com/api/tiktok/followers) - live USD price, lane routing, and measured 30-day uptime. [Every TikTok endpoint](https://getanyapi.com/api/tiktok).

`POST /v1/run/tiktok.followers`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/936db58a-5280-4bbb-a40f-26485a95c6a9

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Pagination cursor from a previous response's nextCursor, to fetch the next page of followers. |
| `handle` | string | Yes | TikTok username whose followers to list, without the @ prefix (e.g. stoolpresidente). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `videoCount` or `secUid`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be abse |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/tiktok.followers","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","handle":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>"}}'
```

### TikTok Following

List the accounts a TikTok user follows (handle, display name, follower count, bio) by username.

**Price:** \$0.80 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [TikTok Following pricing and uptime](https://getanyapi.com/api/tiktok/following) - live USD price, lane routing, and measured 30-day uptime. [Every TikTok endpoint](https://getanyapi.com/api/tiktok).

`POST /v1/run/tiktok.following`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/e424e5ec-c0a6-4a0e-b753-0420fd34920a

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Pagination cursor from a previous response. |
| `handle` | string | Yes | TikTok username without the leading @ (e.g. "stoolpresidente"). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireCursor` | boolean | No | Deprecated; send `requireFields: ["nextCursor"]` instead, which does exactly the same thing. Set true if you intend to page through results, so the request is only served by a source that can return a nextCursor. Omit it and routing is unchanged, with the cheapest source serving. This can raise your price: when the cheapest source cannot page, a source that can serves, and you are quoted and charged its price. It stays accepted so callers that already send it keep working. |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `secUid` or `instagramUrl`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be ab |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/tiktok.following","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","handle":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireCursor":"<boolean>","requireFields":"<string>","source":"<string>"}}'
```

### TikTok Hashtag Videos

List recent TikTok videos for a hashtag (creator, caption, views, likes, shares).

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [TikTok Hashtag Videos pricing and uptime](https://getanyapi.com/api/tiktok/hashtag-videos) - live USD price, lane routing, and measured 30-day uptime. [Every TikTok endpoint](https://getanyapi.com/api/tiktok).

`POST /v1/run/tiktok.hashtag_videos`

**Cost:** Up to $0.007194 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.007194 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/1004d730-840e-4456-bcb7-7b0e42eb4929

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Opaque pagination cursor from a previous response's nextCursor. Omit for the first page; pass it to fetch the next page of videos. |
| `hashtag` | string | Yes | TikTok hashtag to fetch videos for, without the # prefix (e.g. booktok). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum number of results to return (1-20, default 20). |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `playCount`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a video |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/tiktok.hashtag_videos","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","hashtag":"<string>","ignoreSources":"<string>","limit":"<integer>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>"}}'
```

### TikTok Live

Check whether a TikTok creator is live and get the current live room (title, viewers, start time) by handle.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [TikTok Live pricing and uptime](https://getanyapi.com/api/tiktok/live) - live USD price, lane routing, and measured 30-day uptime. [Every TikTok endpoint](https://getanyapi.com/api/tiktok).

`POST /v1/run/tiktok.live`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/30bac453-dda4-4275-958c-ea7678ecf5f7

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `handle` | string | Yes | TikTok username without the leading @ (e.g. "thejustalex"). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/tiktok.live","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","handle":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### TikTok Photos

Get every image in a TikTok photo-mode (slideshow) post by URL, in order, with pixel dimensions and both the clean and watermarked variant of each. Videos carry no images - use tiktok.video_download for those.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [TikTok Photos pricing and uptime](https://getanyapi.com/api/tiktok/photos) - live USD price, lane routing, and measured 30-day uptime. [Every TikTok endpoint](https://getanyapi.com/api/tiktok).

`POST /v1/run/tiktok.photos`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/ef1ddf46-7019-44b1-a847-b5d86e44433e

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `authorFollowers`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Full TikTok photo-mode post URL. TikTok serves slideshow posts under the same /video/<id> path as videos, so the normal share link works. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/tiktok.photos","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>","url":"<string>"}}'
```

### TikTok Playlist Videos

List the videos inside one TikTok playlist by playlist URL or id, in playlist order, with view, like and comment counts.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [TikTok Playlist Videos pricing and uptime](https://getanyapi.com/api/tiktok/playlist-videos) - live USD price, lane routing, and measured 30-day uptime. [Every TikTok endpoint](https://getanyapi.com/api/tiktok).

`POST /v1/run/tiktok.playlist_videos`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/1bf21a45-2394-46ea-9011-a6073f78c6b8

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Pagination cursor from a previous response's nextCursor. |
| `id` | string | No | TikTok playlist id. Use it when tiktok.profile_playlists handed you the id. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum items to return in one page. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | No | Full TikTok playlist URL. The playlist id is the numeric run at the end. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/tiktok.playlist_videos","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","id":"<string>","ignoreSources":"<string>","limit":"<integer>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### TikTok Profile

Fetch a TikTok creator's public profile (followers, likes, bio, verification) by handle.

**Price:** \$0.40 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 7 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [TikTok Profile pricing and uptime](https://getanyapi.com/api/tiktok/profile) - live USD price, lane routing, and measured 30-day uptime. [Every TikTok endpoint](https://getanyapi.com/api/tiktok).

`POST /v1/run/tiktok.profile`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/70e9a5b5-2bca-42f5-83c9-760584a4f43d

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `handle` | string | Yes | TikTok username without the leading @ (e.g. "stoolpresidente"). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `createdUtc`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on an acc |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/tiktok.profile","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","handle":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>"}}'
```

### TikTok Profile Contact Info

Find the public contact email behind a TikTok creator's profile: the address written into the bio plus any published on the site the profile links to, each labelled with where it came from. Returns the creator's profile stats and linked social accounts alongside.

**Price:** billed per result - \$1.16 per 1,000 requests base + \$0.00 per 1,000 results, capped at \$1.16 per 1,000 requests.

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [TikTok Profile Contact Info pricing and uptime](https://getanyapi.com/api/tiktok/profile-contact) - live USD price, lane routing, and measured 30-day uptime. [Every TikTok endpoint](https://getanyapi.com/api/tiktok).

`POST /v1/run/tiktok.profile_contact`

**Cost:** Up to $0.003837 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003837 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/09ab463b-52cd-4d07-856a-a70357066836

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `handle` | string | Yes | TikTok username without the leading @. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `domain` or `sourceUrl`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absen |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/tiktok.profile_contact","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","handle":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>"}}'
```

### TikTok Profile Playlists

List the playlists a TikTok creator has published on their profile, with each playlist's name, video count and cover image.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [TikTok Profile Playlists pricing and uptime](https://getanyapi.com/api/tiktok/profile-playlists) - live USD price, lane routing, and measured 30-day uptime. [Every TikTok endpoint](https://getanyapi.com/api/tiktok).

`POST /v1/run/tiktok.profile_playlists`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/77f35c63-416b-4349-ae10-e4d106449419

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Pagination cursor from a previous response's nextCursor. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum items to return in one page. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `secUid` | string | Yes | TikTok's opaque sec_uid for the account. TikTok's own endpoint keys on it and will not accept a handle; call tiktok.profile with the handle first and read secUid off its response. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/tiktok.profile_playlists","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","ignoreSources":"<string>","limit":"<integer>","preferLatencyUnderMs":"<integer>","secUid":"<string>","source":"<string>"}}'
```

### TikTok Profile Region

Resolve the home region (country) of a TikTok creator by handle.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [TikTok Profile Region pricing and uptime](https://getanyapi.com/api/tiktok/profile-region) - live USD price, lane routing, and measured 30-day uptime. [Every TikTok endpoint](https://getanyapi.com/api/tiktok).

`POST /v1/run/tiktok.profile_region`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/51f4df2b-d540-49ae-83f2-244b82607f57

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `handle` | string | Yes | TikTok username without the leading @ (e.g. "stoolpresidente"). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/tiktok.profile_region","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","handle":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### TikTok Profile Reposts

List the videos a TikTok creator has reposted to their profile, with view, like and comment counts and cursor pagination.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [TikTok Profile Reposts pricing and uptime](https://getanyapi.com/api/tiktok/profile-reposts) - live USD price, lane routing, and measured 30-day uptime. [Every TikTok endpoint](https://getanyapi.com/api/tiktok).

`POST /v1/run/tiktok.profile_reposts`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/dbb5dfa8-3310-4b70-a87b-61e7aab4e2b5

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Pagination cursor from a previous response's nextCursor. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum items to return in one page. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `secUid` | string | Yes | TikTok's opaque sec_uid for the account. TikTok's own endpoint keys on it and will not accept a handle; call tiktok.profile with the handle first and read secUid off its response. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/tiktok.profile_reposts","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","ignoreSources":"<string>","limit":"<integer>","preferLatencyUnderMs":"<integer>","secUid":"<string>","source":"<string>"}}'
```

### TikTok Profile Videos

List a TikTok creator's recent videos (views, likes, comments) by handle with cursor pagination.

**Price:** \$0.60 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 5 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [TikTok Profile Videos pricing and uptime](https://getanyapi.com/api/tiktok/profile-videos) - live USD price, lane routing, and measured 30-day uptime. [Every TikTok endpoint](https://getanyapi.com/api/tiktok).

`POST /v1/run/tiktok.profile_videos`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/e7959422-dc95-4365-abd7-b44e125719ac

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Pagination cursor from a previous response's nextCursor. |
| `handle` | string | Yes | TikTok username without the leading @. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `nextCursor`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a vide |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/tiktok.profile_videos","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","handle":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>"}}'
```

### TikTok Hashtag Search

Search TikTok by hashtag and get matching videos (caption, views, likes, comments, shares) as normalized JSON.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [TikTok Hashtag Search pricing and uptime](https://getanyapi.com/api/tiktok/search-hashtag) - live USD price, lane routing, and measured 30-day uptime. [Every TikTok endpoint](https://getanyapi.com/api/tiktok).

`POST /v1/run/tiktok.search_hashtag`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/a5ab0523-444f-421d-bd75-67112da38e18

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Pagination cursor from a previous response. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Hashtag or keyword to search for (without the leading #). |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `soundTitle` or `locationName`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/tiktok.search_hashtag","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","requireFields":"<string>","source":"<string>"}}'
```

### TikTok Keyword Search

Search TikTok by keyword and get matching videos (caption, views, likes, comments, shares) as normalized JSON.

**Price:** \$0.60 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 5 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [TikTok Keyword Search pricing and uptime](https://getanyapi.com/api/tiktok/search-keyword) - live USD price, lane routing, and measured 30-day uptime. [Every TikTok endpoint](https://getanyapi.com/api/tiktok).

`POST /v1/run/tiktok.search_keyword`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/f8f5c8d6-33f7-4d71-a8af-0620e4d1e412

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Pagination cursor from a previous response. |
| `datePosted` | integer | No | Time frame filter, in days back from now. Use a canonical JSON integer that is nonnegative: 0 for any time, 1 for the past 24 hours, 7 for the past week, 30 for the past month, 90 for the past three months, or 180 for the past six months. Any other number is not guaranteed to filter anything. Legacy numeric strings remain accepted. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | The keyword to search TikTok for. |
| `requireCursor` | boolean | No | Deprecated: name `nextCursor` in `requireFields` instead, which is the field this flag is translated into. It stays accepted so callers that already send it keep working. Sending it routes you to a source that returns a pagination cursor, which can raise your price when the cheapest source cannot page. |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `nextCursor`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a reco |
| `sortBy` | string | No | Sort order: relevance, most-liked, date-posted. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/tiktok.search_keyword","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","datePosted":"<integer>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","requireCursor":"<boolean>","requireFields":"<string>","sortBy":"<string>","source":"<string>"}}'
```

### TikTok Photo Search

Search TikTok for photo-mode (slideshow) posts by keyword, with every image in each post plus view, like and comment counts. tiktok.search_keyword returns videos and drops these.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [TikTok Photo Search pricing and uptime](https://getanyapi.com/api/tiktok/search-photos) - live USD price, lane routing, and measured 30-day uptime. [Every TikTok endpoint](https://getanyapi.com/api/tiktok).

`POST /v1/run/tiktok.search_photos`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/c2266d67-8de4-4af8-9fed-64f46dd7f8fb

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Pagination cursor from a previous response's nextCursor. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum items to return in one page. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Search keyword. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/tiktok.search_photos","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","ignoreSources":"<string>","limit":"<integer>","preferLatencyUnderMs":"<integer>","query":"<string>","source":"<string>"}}'
```

### TikTok Search Suggestions

Get the search terms TikTok suggests for a keyword, each with its language and relative weight - the queries real TikTok users type around your topic.

**Price:** \$0.80 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [TikTok Search Suggestions pricing and uptime](https://getanyapi.com/api/tiktok/search-suggestions) - live USD price, lane routing, and measured 30-day uptime. [Every TikTok endpoint](https://getanyapi.com/api/tiktok).

`POST /v1/run/tiktok.search_suggestions`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/0cf7a3b8-e2f9-42ce-a7d4-a51b12c53852

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Seed keyword to expand. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/tiktok.search_suggestions","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","source":"<string>"}}'
```

### TikTok Top Search

Search TikTok's top results for a keyword (caption, views, likes, comments, shares) with cursor pagination.

**Price:** \$0.60 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 4 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [TikTok Top Search pricing and uptime](https://getanyapi.com/api/tiktok/search-top) - live USD price, lane routing, and measured 30-day uptime. [Every TikTok endpoint](https://getanyapi.com/api/tiktok).

`POST /v1/run/tiktok.search_top`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/a8847993-7f76-4a44-8ffd-c2293d57e5ce

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Pagination cursor from a previous response. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `publishTime` | string | No | Time-frame filter: yesterday, this-week, this-month, last-3-months, last-6-months, all-time. |
| `query` | string | Yes | Keyword to search for (e.g. "funny"). |
| `region` | string | No | 2-letter country code for the proxy location (e.g. US, GB, FR). |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `soundClipId` or `nextCursor`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be |
| `sortBy` | string | No | Sort order: relevance, most-liked, date-posted. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/tiktok.search_top","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","publishTime":"<string>","query":"<string>","region":"<string>","requireFields":"<string>","sortBy":"<string>","source":"<string>"}}'
```

### TikTok User Search

Search TikTok accounts by keyword (handle, nickname, follower count) with cursor pagination.

**Price:** \$0.60 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 6 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [TikTok User Search pricing and uptime](https://getanyapi.com/api/tiktok/search-users) - live USD price, lane routing, and measured 30-day uptime. [Every TikTok endpoint](https://getanyapi.com/api/tiktok).

`POST /v1/run/tiktok.search_users`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/79af35f4-a2c9-42cc-b37e-d406c075af0a

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Pagination cursor from a previous response's nextCursor. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | The keyword to search TikTok accounts for. |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `secUid` or `bio`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/tiktok.search_users","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","requireFields":"<string>","source":"<string>"}}'
```

### TikTok Song

Fetch details for a TikTok song or sound (title, author, duration, cover art, and how many videos use it).

**Price:** \$0.60 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [TikTok Song pricing and uptime](https://getanyapi.com/api/tiktok/song) - live USD price, lane routing, and measured 30-day uptime. [Every TikTok endpoint](https://getanyapi.com/api/tiktok).

`POST /v1/run/tiktok.song`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/f18cc485-d60f-4f49-bb4a-c65d9eadfaa3

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `clipId` | string | Yes | The clip identifier for the song, found in TikTok music URLs (e.g. 7439295283975702544). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/tiktok.song","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","clipId":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### TikTok Song Videos

List TikTok videos that use a given song or sound (with descriptions, authors, and engagement stats).

**Price:** \$0.60 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 4 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [TikTok Song Videos pricing and uptime](https://getanyapi.com/api/tiktok/song-videos) - live USD price, lane routing, and measured 30-day uptime. [Every TikTok endpoint](https://getanyapi.com/api/tiktok).

`POST /v1/run/tiktok.song_videos`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/bbe70240-f33b-432c-891c-2985adfbd2b4

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `clipId` | string | Yes | The song ID found in TikTok music URLs (e.g. 7439295283975702544). |
| `cursor` | string | No | Pagination cursor for retrieving the next page of results. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `nextCursor`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a reco |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/tiktok.song_videos","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","clipId":"<string>","cursor":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>"}}'
```

### TikTok Top Ads Search

Search TikTok Creative Center top video ads by keyword, with campaign objective, performance percentile, and time-window filters.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [TikTok Top Ads Search pricing and uptime](https://getanyapi.com/api/tiktok/top-ads-search) - live USD price, lane routing, and measured 30-day uptime. [Every TikTok endpoint](https://getanyapi.com/api/tiktok).

`POST /v1/run/tiktok.top_ads_search`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/579e8f12-ad2d-4240-ab8a-8fd0632dd70f

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum number of ads requested for this page, from 1 through 20 (default 20). |
| `objective` | string | No | Campaign objective filter. Omit it to search every objective. |
| `page` | integer | No | One-based provider page number (default 1). |
| `performanceRank` | string | No | Ad performance percentile bucket, where top_1_20 is the highest-performing 20 percent. Omit it to search every bucket. |
| `period` | integer | No | Lookback period in days (default 180). |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Keyword to search in TikTok Creative Center top video ads. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/tiktok.top_ads_search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","limit":"<integer>","objective":"<string>","page":"<integer>","performanceRank":"<string>","period":"<integer>","preferLatencyUnderMs":"<integer>","query":"<string>","source":"<string>"}}'
```

### TikTok Trending Feed

Sample TikTok's For You feed as served to a viewer in one country (caption, views, likes, comments, author). Returns a rotating sample, not a ranked chart.

**Price:** \$0.80 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [TikTok Trending Feed pricing and uptime](https://getanyapi.com/api/tiktok/trending-feed) - live USD price, lane routing, and measured 30-day uptime. [Every TikTok endpoint](https://getanyapi.com/api/tiktok).

`POST /v1/run/tiktok.trending_feed`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/091f75ff-f432-4539-822b-5ec1ac313a21

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `region` | string | Yes | 2-letter country code for the proxy location (e.g. "US"). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `trim` | string | No | Set to true to return a simplified response. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/tiktok.trending_feed","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","region":"<string>","source":"<string>","trim":"<string>"}}'
```

### TikTok Trending Hashtags

Rank TikTok's trending hashtags for one country and industry, with each hashtag's daily popularity curve, post count, video views, and leading creators. Ranks 15 industry categories, or omit industry for the all-industries board. TikTok publishes only the top 3 hashtags per board to anonymous callers, so limit 1-3 is served cheaply; a limit above 3 routes to a dearer authenticated source that returns the full ranking. Covers 27 markets: AE, AR, AU, BR, CA, CO, DE, EG, ES, FR, GB, ID, IL, IT, JP, KR, MX, MY, PH, SA, SG, TH, TR, TW, US, VN, ZA.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [TikTok Trending Hashtags pricing and uptime](https://getanyapi.com/api/tiktok/trending-hashtags) - live USD price, lane routing, an

`POST /v1/run/tiktok.trending_hashtags`

**Cost:** Up to $0.089925 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.089925 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/3e9f05ac-205e-41a5-803b-0777c7b31e04

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `industry` | string | No | Restrict the ranking to one industry. Omit for the all-industries board. |
| `limit` | integer | No | Maximum number of ranked hashtags to return, from 1 through 100 (default 3). TikTok publishes only the top 3 hashtags per board to anonymous callers, so 1 through 3 is served by the cheapest source; a higher limit routes to a dearer source that reads the full ranking. |
| `period` | integer | No | Lookback window in days that the ranking and the popularity curve cover (default 7). |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `region` | string | No | Two-letter country code of the market whose hashtag ranking to read (default US). Each market is ranked independently, so US and DE return different boards. |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `industryIds`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a has |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/tiktok.trending_hashtags","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","industry":"<string>","limit":"<integer>","period":"<integer>","preferLatencyUnderMs":"<integer>","region":"<string>","requireFields":"<string>","source":"<string>"}}'
```

### TikTok User Stories

Get a TikTok creator's active public stories by username: video or photo links, cover, posting and expiry times, and view, like, share and save counts.

**Price:** \$1.10 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [TikTok User Stories pricing and uptime](https://getanyapi.com/api/tiktok/user-stories) - live USD price, lane routing, and measured 30-day uptime. [Every TikTok endpoint](https://getanyapi.com/api/tiktok).

`POST /v1/run/tiktok.user_stories`

**Cost:** Up to $0.001199 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001199 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/cee11e1f-96b3-4fda-8f30-5b440f4c6bc5

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `handle` | string | Yes | TikTok username, without the @ (e.g. "jasonderulo"). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `expiresUtc`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a stor |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/tiktok.user_stories","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","handle":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>"}}'
```

### TikTok Video

Fetch a single TikTok video by URL with its caption and engagement counts (views, likes, comments, shares, saves).

**Price:** \$0.40 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 5 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [TikTok Video pricing and uptime](https://getanyapi.com/api/tiktok/video) - live USD price, lane routing, and measured 30-day uptime. [Every TikTok endpoint](https://getanyapi.com/api/tiktok).

`POST /v1/run/tiktok.video`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/87578e79-b10f-4b80-92cc-a9ac8b29c0d3

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `id` | string | No | TikTok video ID, the numeric run at the end of a video URL. Use it when a listing SKU handed you an id and no URL. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `views`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a video tha |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | No | Full TikTok video URL. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/tiktok.video","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","id":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>","url":"<string>"}}'
```

### TikTok Video Comments

List the comments on a TikTok video by URL with cursor pagination (text, author, likes, reply count).

**Price:** \$0.60 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 6 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [TikTok Video Comments pricing and uptime](https://getanyapi.com/api/tiktok/video-comments) - live USD price, lane routing, and measured 30-day uptime. [Every TikTok endpoint](https://getanyapi.com/api/tiktok).

`POST /v1/run/tiktok.video_comments`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/cd81f5cd-094c-4d74-8b26-5dd9e2549970

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Pagination cursor from a previous response's nextCursor. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `authorUserId` or `language`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | TikTok post URL on tiktok.com: a video or photo post (https://www.tiktok.com/@<user>/video/<id> or /photo/<id>) or a vm.tiktok.com or vt.tiktok.com short link. A profile link (https://www.tiktok.com/@<user>), a video file link (tiktokcdn.com) or a link to any other site is refused as invalid input, with no charge. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/tiktok.video_comments","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>","url":"<string>"}}'
```

### TikTok Video Download

Get the playable media files behind a TikTok video URL: the clean no-watermark MP4, the watermarked one TikTok's own save button produces, and the cover image, with duration and pixel dimensions. Photo-mode posts carry no video file - use tiktok.photos for those.

**Price:** \$0.80 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [TikTok Video Download pricing and uptime](https://getanyapi.com/api/tiktok/video-download) - live USD price, lane routing, and measured 30-day uptime. [Every TikTok endpoint](https://getanyapi.com/api/tiktok).

`POST /v1/run/tiktok.video_download`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/2c717b2d-5bba-4864-845c-c9ee22a3d3af

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `height` or `width`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Full TikTok video URL. Share links and tracking query params are fine. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/tiktok.video_download","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>","url":"<string>"}}'
```

### TikTok Video Transcript (native captions)

Fetch the caption track TikTok itself published for a video, as TikTok wrote it. It is the cheapest way to get the words, and it is only as good as TikTok's own transcription: it mishears names and uncommon words, and many videos - especially non-English ones - have no caption track at all, which comes back as not found. When you need the words to be right, or there is no track to read, tiktok.video_transcript_full transcribes the audio with AnyAPI's own speech-to-text instead.

**Price:** \$1.10 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 4 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [TikTok Video Transcript (native captions) pricing and uptime](https://getanyapi.com/api/tiktok/video-transcript) - live USD price, lane routing, and measured 30-day uptime. [Every TikTok endpoint](

`POST /v1/run/tiktok.video_transcript`

**Cost:** Up to $0.03488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.03488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/0a87862e-30c3-4e47-a75e-85ceee3063ac

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `language`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a video |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | TikTok video URL on tiktok.com: a video or photo post (https://www.tiktok.com/@<user>/video/<id> or /photo/<id>) or a vm.tiktok.com, vt.tiktok.com or tiktok.com/t/ share link. A profile link (https://www.tiktok.com/@<user>), a /@<user>/<id> link without /video/ (TikTok sends it to the For You feed, not a video), a video file link (tiktokcdn.com) or a link to any other site is refused as invalid input, with no charge. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/tiktok.video_transcript","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>","url":"<string>"}}'
```

### TikTok Video Transcript (AnyAPI speech to text)

Transcribe the spoken audio of a TikTok video with AnyAPI's own speech-to-text: timed sentence-level segments, speaker labels, detected language, and optional per-word timings, for videos TikTok publishes no caption track for and for videos whose caption track gets the words wrong. AnyAPI downloads the video and runs the audio through MAI-Transcribe-2 rather than reading anything TikTok wrote, which is why it handles non-English speech and hears words the native captions mishear. The answer also carries the video's id, URL, creator handle, and cover image. Turn on hostVideo to also get the MP4 on a hosted link that plays without TikTok's signed, short-lived CDN URL expiring on you. If you only want whatever TikTok itself published and you want it for a tenth of the price, tiktok.video_transcript is that.

**Price:** billed per audio minute - \$1.50 per 1,000 requests base + \$6.00 per 1,000 audio minutes, capped at \$95.00 per 1,000 requests.

**Routing:** one lane serves this API toda

`POST /v1/run/tiktok.video_transcript_full`

**Cost:** Up to $0.108455 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.108455 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/b557ddc6-f32b-4b95-95f2-5b38f4cc0fba

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `hostVideo` | boolean | No | Also store the video and return a hosted MP4 link that plays without TikTok's signed CDN URL. Charged as an extra on top of the transcript. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | TikTok video URL (e.g. "https://www.tiktok.com/@user/video/1234567890"). |
| `wordTimestamps` | boolean | No | Return per-word timings inside each segment. Words carry timings only; the recognizer scores a phrase rather than a word, so there is no per-word confidence to report. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/tiktok.video_transcript_full","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","hostVideo":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>","wordTimestamps":"<boolean>"}}'
```

### TikTok Shop Categories

List the TikTok Shop category tree for a market: top-level categories with ids, slugs, and images, each with its child categories.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [TikTok Shop Categories pricing and uptime](https://getanyapi.com/api/tiktok-shop/categories) - live USD price, lane routing, and measured 30-day uptime. [Every TikTok Shop endpoint](https://getanyapi.com/api/tiktok-shop).

`POST /v1/run/tiktok_shop.categories`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/5c8aac80-f00c-4b05-8329-8c541f390942

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `region` | string | No | Country code of the TikTok Shop market whose category tree to list. Only US and VN publish a category tree. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/tiktok_shop.categories","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","region":"<string>","source":"<string>"}}'
```

### TikTok Shop Creator

TikTok Shop creator performance by handle: GMV range, promoted product count, brand collaborations, follower age/gender/location demographics, category GMV split, and video versus live engagement.

**Price:** billed per result - \$5.50 per 1,000 requests base + \$0.00 per 1,000 results, capped at \$5.50 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [TikTok Shop Creator pricing and uptime](https://getanyapi.com/api/tiktok-shop/creator) - live USD price, lane routing, and measured 30-day uptime. [Every TikTok Shop endpoint](https://getanyapi.com/api/tiktok-shop).

`POST /v1/run/tiktok_shop.creator`

**Cost:** Up to $0.005995 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.005995 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/d7b1cde1-deae-4b61-853a-a34981af92e2

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `handle` | string | Yes | TikTok handle of the creator or shop account, without the @ (e.g. golinutrition). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `region` | string | No | Country code of the TikTok Shop market. Only the US market is served; creators in other markets are not available. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/tiktok_shop.creator","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","handle":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","region":"<string>","source":"<string>"}}'
```

### TikTok Shop Product

Fetch TikTok Shop product details (title, price, sales, seller, and ratings) from a product URL.

**Price:** \$0.95 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [TikTok Shop Product pricing and uptime](https://getanyapi.com/api/tiktok-shop/product) - live USD price, lane routing, and measured 30-day uptime. [Every TikTok Shop endpoint](https://getanyapi.com/api/tiktok-shop).

`POST /v1/run/tiktok_shop.product`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/c0498aaa-16a0-4e67-a81b-d52a2026c3b6

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `region` | string | No | Two-letter country code for the proxy location used to access region-specific products (e.g. US, GB, FR). Defaults to US. |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `sellerLocation`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | TikTok Shop product detail page URL (e.g. https://www.tiktok.com/shop/pdp/.../1729587769570529799). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/tiktok_shop.product","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","region":"<string>","requireFields":"<string>","source":"<string>","url":"<string>"}}'
```

### TikTok Shop Product Reviews

Fetch customer reviews for a TikTok Shop product by URL (rating, text, reviewer, country, and verified-purchase flag).

**Price:** \$0.95 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [TikTok Shop Product Reviews pricing and uptime](https://getanyapi.com/api/tiktok-shop/product-reviews) - live USD price, lane routing, and measured 30-day uptime. [Every TikTok Shop endpoint](https://getanyapi.com/api/tiktok-shop).

`POST /v1/run/tiktok_shop.product_reviews`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/64b29950-676b-4d93-b867-329c95b1f8c6

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `page` | integer | No | 1-based results page. Use with hasMore in the output to paginate. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `region` | string | No | Two-letter country code of the product's shop region (e.g. US). Strongly recommended for correct results. |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `images`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be empty on a review th |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | TikTok Shop product URL (e.g. https://www.tiktok.com/shop/pdp/.../1729385633899532161). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/tiktok_shop.product_reviews","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","page":"<integer>","preferLatencyUnderMs":"<integer>","region":"<string>","requireFields":"<string>","source":"<string>","url":"<string>"}}'
```

### TikTok Shop Search

Search TikTok Shop products by keyword across 15 countries: price, sales, rating, and seller info per product, in one normalized response.

**Price:** \$0.95 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 4 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [TikTok Shop Search pricing and uptime](https://getanyapi.com/api/tiktok-shop/search) - live USD price, lane routing, and measured 30-day uptime. [Every TikTok Shop endpoint](https://getanyapi.com/api/tiktok-shop).

`POST /v1/run/tiktok_shop.search`

**Cost:** Up to $0.001635 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001635 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/4062147e-1e74-4bc7-b956-9940f808784a

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `country` | string | No | Country code of the TikTok Shop market to search (e.g. US). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum products to return, honoured on US searches up to 30. Other countries and larger values return every product TikTok Shop gives for the query, typically about 30 and occasionally more than 50. The price per call is the same either way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Search keyword for TikTok Shop products (e.g. wireless earbuds). |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `currency`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a produc |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/tiktok_shop.search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","country":"<string>","ignoreSources":"<string>","limit":"<integer>","preferLatencyUnderMs":"<integer>","query":"<string>","requireFields":"<string>","source":"<string>"}}'
```

### TikTok Shop Search Suggestions

Get TikTok Shop search autocomplete terms for a keyword: the long-tail queries shoppers actually type, for keyword and demand research.

**Price:** \$0.95 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [TikTok Shop Search Suggestions pricing and uptime](https://getanyapi.com/api/tiktok-shop/search-suggestions) - live USD price, lane routing, and measured 30-day uptime. [Every TikTok Shop endpoint](https://getanyapi.com/api/tiktok-shop).

`POST /v1/run/tiktok_shop.search_suggestions`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/b936362d-9469-4098-a00e-9896863fef2e

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `country` | string | No | Two-letter country code of the TikTok Shop market (e.g. US). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `language` | string | No | Language tag for the suggestions (e.g. en-US). |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Seed keyword to expand (e.g. ashwagandha gummies). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/tiktok_shop.search_suggestions","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","country":"<string>","ignoreSources":"<string>","language":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","source":"<string>"}}'
```

### TikTok Shop Store Products

List every product of a TikTok Shop store by URL (title, price, sales, and rating per product plus shop-level stats) with cursor pagination.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [TikTok Shop Store Products pricing and uptime](https://getanyapi.com/api/tiktok-shop/shop-products) - live USD price, lane routing, and measured 30-day uptime. [Every TikTok Shop endpoint](https://getanyapi.com/api/tiktok-shop).

`POST /v1/run/tiktok_shop.shop_products`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/019655da-85df-4a5f-b58b-4a163d804f6a

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Opaque pagination cursor from a previous response's nextCursor. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `region` | string | No | Two-letter country code of the store's market (e.g. US). |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `shopRating`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a stor |
| `sortBy` | string | No | Product ordering within the store. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | TikTok Shop store URL (e.g. https://www.tiktok.com/shop/store/<name>/<id> or https://shop.tiktok.com/us/store/<name>/<id>). The link must include the store's numeric id, the long number after the store name: a link with only the name (tiktok.com/shop/store/<name>) does not open a store page on TikTok. A link without the store id, a vt.tiktok.com or vm.tiktok.com share link, or any link that is not a store page, is refused as invalid input, with no charge; send the store page link with its id (ti |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/tiktok_shop.shop_products","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","region":"<string>","requireFields":"<string>","sortBy":"<string>","source":"<string>","url":"<string>"}}'
```

### TikTok Shop User Showcase

List the TikTok Shop products a creator showcases (title, price, rating, and sales per product).

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [TikTok Shop User Showcase pricing and uptime](https://getanyapi.com/api/tiktok-shop/user-showcase) - live USD price, lane routing, and measured 30-day uptime. [Every TikTok Shop endpoint](https://getanyapi.com/api/tiktok-shop).

`POST /v1/run/tiktok_shop.user_showcase`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/bc68f779-6f6b-46c4-9cc7-418976d1a453

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Pagination token for retrieving subsequent product pages. |
| `handle` | string | Yes | The handle of the TikTok user (e.g. mrtiktokreviews). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `region` | string | No | Geographical region for proxy placement (defaults to US). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/tiktok_shop.user_showcase","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","handle":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","region":"<string>","source":"<string>"}}'
```

### Tripadvisor Reviews

Fetch the latest reviews for any Tripadvisor hotel, restaurant, or attraction by its page URL: rating, text, date, and trip details as normalized JSON.

**Price:** \$3.00 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Tripadvisor Reviews pricing and uptime](https://getanyapi.com/api/tripadvisor/reviews) - live USD price, lane routing, and measured 30-day uptime. [Every Tripadvisor endpoint](https://getanyapi.com/api/tripadvisor).

`POST /v1/run/tripadvisor.reviews`

**Cost:** Up to $0.01199 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.01199 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/4df0723e-d42e-4497-98fd-1488ce7a18e5

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Pagination cursor from a previous response's nextCursor. Omit for the first page. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `languages` | string | No | Only return reviews originally written in these ISO 639-1 languages (e.g. ["en", "es"]); omit for all languages. Reviews are never translated. Each page is filtered after it is fetched, so a page can hold fewer than `limit` reviews, or none, while nextCursor still leads to more. |
| `limit` | integer | No | Reviews per page (1-20, default 20). Sources that page return one page of up to `limit` reviews, newest first, with a nextCursor for the next page; sources that cannot page return up to `limit` reviews in one call with no nextCursor. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `ratings` | string | No | Only return reviews whose bubble rating is in this set (e.g. ["5", "4"] for 4 and 5 star reviews); omit for all ratings. |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `nextCursor`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. nextCursor is null on the last page. Naming |
| `since` | string | No | Only return reviews newer than this date, YYYY-MM-DD or a relative window like '3 months' (e.g. 2026-01-01). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Tripadvisor page URL of the hotel, restaurant, or attraction. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/tripadvisor.reviews","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","ignoreSources":"<string>","languages":"<string>","limit":"<integer>","preferLatencyUnderMs":"<integer>","ratings":"<string>","requireFields":"<string>","since":"<string>","source":"<string>","url":"<string>"}}'
```

### Tripadvisor Search

Search Tripadvisor for hotels, restaurants, and attractions in any destination and get rich place records (ratings, review counts, contact details, pricing) as normalized JSON.

**Price:** \$3.00 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Tripadvisor Search pricing and uptime](https://getanyapi.com/api/tripadvisor/search) - live USD price, lane routing, and measured 30-day uptime. [Every Tripadvisor endpoint](https://getanyapi.com/api/tripadvisor).

`POST /v1/run/tripadvisor.search`

**Cost:** Up to $0.048178 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.048178 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/f93eb1c6-3a5f-4a54-9c83-c0c126569102

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `currency` | string | No | ISO currency code for prices (e.g. USD, EUR). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `includeAttractions` | boolean | No | Include attractions and things to do in the results; set false to exclude them (e.g. false). Defaults to true. |
| `includeHotels` | boolean | No | Include hotels in the results; set false to exclude them (e.g. false). Defaults to true. |
| `includeRestaurants` | boolean | No | Include restaurants in the results; set false to exclude them (e.g. false). Defaults to true. |
| `limit` | integer | No | Maximum number of results to return (1-20, default 20). |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Destination or keyword to search for (e.g. Barcelona). |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `phone` or `website`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent o |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/tripadvisor.search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","currency":"<string>","ignoreSources":"<string>","includeAttractions":"<boolean>","includeHotels":"<boolean>","includeRestaurants":"<boolean>","limit":"<integer>","preferLatencyUnderMs":"<integer>","query":"<string>","requireFields":"<string>","source":"<string>"}}'
```

### Trustpilot Reviews

Pull Trustpilot reviews for any company by brand name: star ratings, review text, dates, and reviewer details as clean JSON.

**Price:** \$2.14 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Trustpilot Reviews pricing and uptime](https://getanyapi.com/api/trustpilot/reviews) - live USD price, lane routing, and measured 30-day uptime. [Every Trustpilot endpoint](https://getanyapi.com/api/trustpilot).

`POST /v1/run/trustpilot.reviews`

**Cost:** Up to $0.15042 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.15042 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/929ee9dd-7f08-416f-ab84-5aeab9d935f8

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `company` | string | Yes | Brand name or Trustpilot review-page URL to fetch reviews for (e.g. nike or https://www.trustpilot.com/review/nike.com). |
| `countries` | string | No | Only return reviews from reviewers in these ISO 3166-1 alpha-2 countries (e.g. ["US", "GB"]). Omit this field for all countries and to stay on the cheapest price; a country filter routes to the dearest source. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `languages` | string | No | Only return reviews in these ISO 639-1 languages (e.g. ["en", "de"]). Omit this field for all languages and to stay on the cheapest price; a language filter routes to the dearest source. |
| `limit` | integer | No | Maximum number of results to return (1-200, default 200). Trustpilot serves at most 200 reviews per company. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `avatarUrl`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a revie |
| `sortBy` | string | No | Review ordering: auto, relevancy, or recent (e.g. recent). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `stars` | string | No | Limit reviews to a single star rating from 1 to 5 (e.g. 5). |
| `startDate` | string | No | Only return reviews on or after this date, inclusive, in YYYY-MM-DD format (e.g. 2026-01-01). Omit this field to stay on the cheapest price; a date floor routes to the dearest source. |
| `verifiedOnly` | boolean | No | Set true to return only verified reviews (e.g. true). Omit this field, or send false, to stay on the cheapest price; true routes to a dearer source. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/trustpilot.reviews","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","company":"<string>","countries":"<string>","ignoreSources":"<string>","languages":"<string>","limit":"<integer>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","sortBy":"<string>","source":"<string>","stars":"<string>","startDate":"<string>","verifiedOnly":"<boolean>"}}'
```

### Truth Social Post

Get a single Truth Social post by its URL - text, author, engagement (likes, comments, shares), and timestamp as clean JSON.

**Price:** \$1.10 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Truth Social Post pricing and uptime](https://getanyapi.com/api/truthsocial/post) - live USD price, lane routing, and measured 30-day uptime. [Every Truthsocial endpoint](https://getanyapi.com/api/truthsocial).

`POST /v1/run/truthsocial.post`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/0a132b0e-e47e-4d15-921e-3b07561ee1eb

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Full Truth Social post URL, e.g. "https://truthsocial.com/@realDonaldTrump/posts/116824551176646175". |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/truthsocial.post","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### Truth Social Profile

Get a Truth Social account's public profile by handle - display name, bio, follower/following counts, and post count as clean JSON.

**Price:** \$1.10 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Truth Social Profile pricing and uptime](https://getanyapi.com/api/truthsocial/profile) - live USD price, lane routing, and measured 30-day uptime. [Every Truthsocial endpoint](https://getanyapi.com/api/truthsocial).

`POST /v1/run/truthsocial.profile`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/f51db0d6-ef8c-47f1-8f19-afec309896b7

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `handle` | string | Yes | Truth Social handle without the @, e.g. "realDonaldTrump". |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/truthsocial.profile","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","handle":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### Truth Social User Posts

List a Truth Social account's recent posts by handle - text, engagement (likes, comments, shares), and timestamps as clean JSON.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Truth Social User Posts pricing and uptime](https://getanyapi.com/api/truthsocial/user-posts) - live USD price, lane routing, and measured 30-day uptime. [Every Truthsocial endpoint](https://getanyapi.com/api/truthsocial).

`POST /v1/run/truthsocial.user_posts`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/d9aa34dd-9716-4f4f-ba83-9cb4e536bd5b

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Opaque pagination cursor from a previous response's nextCursor. Omit for the first page; a page holds 20 posts. |
| `handle` | string | Yes | Truth Social handle without the @, e.g. "realDonaldTrump". |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/truthsocial.user_posts","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","handle":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### X / Twitter Article

Get a public X long-form article from its wrapper post URL, including its author, engagement, cover image, and structured content blocks.

**Price:** \$0.54 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [X / Twitter Article pricing and uptime](https://getanyapi.com/api/x-twitter/article) - live USD price, lane routing, and measured 30-day uptime. [Every X (Twitter) endpoint](https://getanyapi.com/api/x-twitter).

`POST /v1/run/twitter.article`

**Cost:** Up to $0.000534 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.000534 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/1501d0b7-7aec-4b58-8a31-0dcaebdf1755

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Canonical x.com or twitter.com URL of the public wrapper post for an X Article. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/twitter.article","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### Twitter Community

Fetch a Twitter/X community's public details (name, description, member count, join policy) by URL.

**Price:** \$0.10 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Twitter Community pricing and uptime](https://getanyapi.com/api/x-twitter/community) - live USD price, lane routing, and measured 30-day uptime. [Every X (Twitter) endpoint](https://getanyapi.com/api/x-twitter).

`POST /v1/run/twitter.community`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/21e63bc1-c1df-4bca-87ba-493a7bc49e62

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Community URL (e.g. https://x.com/i/communities/1926186499399139650). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/twitter.community","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### Twitter Community Tweets

List recent tweets posted in a Twitter/X community by URL.

**Price:** \$0.45 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 4 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Twitter Community Tweets pricing and uptime](https://getanyapi.com/api/x-twitter/community-tweets) - live USD price, lane routing, and measured 30-day uptime. [Every X (Twitter) endpoint](https://getanyapi.com/api/x-twitter).

`POST /v1/run/twitter.community_tweets`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/add23482-964a-4679-81fe-6c966a59e79f

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Community URL (e.g. https://x.com/i/communities/1926186499399139650). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/twitter.community_tweets","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### X / Twitter Followers

Fetch the follower list of any public X (Twitter) account by username with cursor pagination. Limit is a per-page maximum and a native page holds up to 200 accounts; follow the response's nextCursor for more.

**Price:** \$0.45 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [X / Twitter Followers pricing and uptime](https://getanyapi.com/api/x-twitter/followers) - live USD price, lane routing, and measured 30-day uptime. [Every X (Twitter) endpoint](https://getanyapi.com/api/x-twitter).

`POST /v1/run/twitter.followers`

**Cost:** Up to $0.000534 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.000534 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/1c2eecfa-103d-4fa1-9093-a0e9cf1a3872

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Opaque pagination cursor from a previous response's nextCursor. Omit for the first page; pass it to fetch the next page of followers. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Accepted but does not change the page: every call returns one full native page of followers (up to 200, depending on the source), never trimmed, so follow nextCursor to continue exactly where this response ended. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `bio`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a profile tha |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `username` | string | Yes | The X (Twitter) username to fetch followers for, without the @ prefix (e.g. elonmusk). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/twitter.followers","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","ignoreSources":"<string>","limit":"<integer>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>","username":"<string>"}}'
```

### X / Twitter Following

List the accounts a public X (Twitter) account follows by username with cursor pagination. Limit is a per-page maximum; follow the response's nextCursor for more.

**Price:** \$0.45 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [X / Twitter Following pricing and uptime](https://getanyapi.com/api/x-twitter/following) - live USD price, lane routing, and measured 30-day uptime. [Every X (Twitter) endpoint](https://getanyapi.com/api/x-twitter).

`POST /v1/run/twitter.following`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/509b67b5-5c04-4361-bdc9-7986c80ac3e7

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Opaque pagination cursor from a previous response's nextCursor. Omit for the first page; pass it to fetch the next page of followed accounts. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Accepted but does not change the page: every call returns one full native page of followed accounts (about 50), never trimmed, so follow nextCursor to continue exactly where this response ended. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `location`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a profil |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `username` | string | Yes | The X (Twitter) username to fetch the following list for, without the @ prefix (e.g. elonmusk). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/twitter.following","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","ignoreSources":"<string>","limit":"<integer>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>","username":"<string>"}}'
```

### Twitter Profile

Fetch a Twitter/X account's public profile (followers, tweets, bio, verification) by handle.

**Price:** \$0.22 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 5 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Twitter Profile pricing and uptime](https://getanyapi.com/api/x-twitter/profile) - live USD price, lane routing, and measured 30-day uptime. [Every X (Twitter) endpoint](https://getanyapi.com/api/x-twitter).

`POST /v1/run/twitter.profile`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/0ff5a4e9-eac1-4928-9582-6268fb67d4e6

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `handle` | string | Yes | Twitter/X handle without the leading @. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/twitter.profile","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","handle":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### X / Twitter Post Replies

Fetch the replies to any X (Twitter) post URL as structured records: author, text, and engagement. An empty result is valid and does not assert whether the target post exists.

**Price:** \$0.45 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 4 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [X / Twitter Post Replies pricing and uptime](https://getanyapi.com/api/x-twitter/replies) - live USD price, lane routing, and measured 30-day uptime. [Every X (Twitter) endpoint](https://getanyapi.com/api/x-twitter).

`POST /v1/run/twitter.replies`

**Cost:** Up to $0.009657 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.009657 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/6834f455-993f-441e-862b-832ecd3fc088

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Opaque pagination cursor from a previous response's nextCursor. Omit for the first page; pass it to fetch the next page of replies. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum number of results to return (1-40, default 40). Per-result lanes cost less at lower limits; a backup that bills its native page may cost up to the advertised request price. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `nextCursor`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. Naming a combination that no single source |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Full URL of the X (Twitter) post to fetch replies for (e.g. https://x.com/nasa/status/1846987139428634858). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/twitter.replies","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","ignoreSources":"<string>","limit":"<integer>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>","url":"<string>"}}'
```

### X / Twitter Search

Search X (Twitter) with full advanced-search syntax (operators like from:, since:, until:, min_faves: work inline in the query) and get structured tweets with text, author, engagement, and cursor pagination. Limit is a per-page maximum; native pages contain approximately 20 tweets unless requireSinglePage selects a bulk lane.

**Price:** \$0.54 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 4 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [X / Twitter Search pricing and uptime](https://getanyapi.com/api/x-twitter/search) - live USD price, lane routing, and measured 30-day uptime. [Every X (Twitter) endpoint](https://getanyapi.com/api/x-twitter).

`POST /v1/run/twitter.search`

**Cost:** Up to $0.005559 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.005559 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/24767179-36d7-4707-9187-7a68c4377afd

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Opaque pagination cursor from a previous response's nextCursor. Omit for the first page; pass it to fetch the next page of search results. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Page size to ask for (1-50, default 20). Some sources honor it; others always return their whole native page of about 20. A page is never trimmed after the call, so follow nextCursor to continue exactly where this response ended. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Search query using X (Twitter) advanced-search syntax. IMPORTANT: bare terms are ANDed - a tweet must contain EVERY word, so a list of loosely related keywords matches nothing; use one short phrase or OR between alternatives (e.g. 'anyapi OR getanyapi'). When an operator follows an OR list, put the list in parentheses, e.g. '(anyapi OR getanyapi) -filter:replies': without them X applies the operator to the last alternative only, so such a query still runs as X reads it and the response's hint ca |
| `queryType` | string | No | Which posts to return: 'Latest' (newest first, the default), 'Top' (most popular), 'Photos' (newest posts with images), or 'Videos' (newest posts with video). Photos and Videos search your query as written with filter:images or filter:videos added after it, so they cost the same as a Latest search. |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `nextCursor`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a post |
| `requireSinglePage` | boolean | No | Set true to get up to limit results in one response instead of provider-native pages, served by a bulk provider when needed. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/twitter.search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","ignoreSources":"<string>","limit":"<integer>","preferLatencyUnderMs":"<integer>","query":"<string>","queryType":"<string>","requireFields":"<string>","requireSinglePage":"<boolean>","source":"<string>"}}'
```

### X / Twitter User Search

Search X (Twitter) accounts by keyword - the People tab of X search. Matches handles, display names, and profile bios, and returns normalized profile records with follower, following, and post counts plus cursor pagination. Use twitter.search for posts.

**Price:** \$0.54 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [X / Twitter User Search pricing and uptime](https://getanyapi.com/api/x-twitter/search-users) - live USD price, lane routing, and measured 30-day uptime. [Every X (Twitter) endpoint](https://getanyapi.com/api/x-twitter).

`POST /v1/run/twitter.search_users`

**Cost:** Up to $0.002289 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.002289 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/066d3c2c-637f-4f78-bb95-a63a95eaefb7

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Opaque pagination cursor from a previous response's nextCursor. Omit for the first page; pass it to fetch the next page of accounts. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Keyword to match against X (Twitter) handles, display names, and profile bios. This is the People tab of X search: pass a topic ('ai agents'), a name ('Elon Musk'), or a handle ('openai') and get back accounts, not posts. Use twitter.search for posts. |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `location`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a profil |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/twitter.search_users","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","requireFields":"<string>","source":"<string>"}}'
```

### X / Twitter Tweet Thread

Resolve the linear self-thread containing an X (Twitter) post, from its root through the author's linked continuations. This excludes replies from other users.

**Price:** \$2.69 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [X / Twitter Tweet Thread pricing and uptime](https://getanyapi.com/api/x-twitter/thread) - live USD price, lane routing, and measured 30-day uptime. [Every X (Twitter) endpoint](https://getanyapi.com/api/x-twitter).

`POST /v1/run/twitter.thread`

**Cost:** Up to $0.002638 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.002638 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/cd8b22e3-29a6-4fa0-ba17-3c92a3f5084d

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Canonical x.com or twitter.com status URL with a numeric tweet ID. Any tweet in the self-thread can be supplied; the provider resolves the thread root. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/twitter.thread","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### Weibo Advanced Search

Search public Weibo posts with optional result, media, and time filters.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Weibo Advanced Search pricing and uptime](https://getanyapi.com/api/weibo/search) - live USD price, lane routing, and measured 30-day uptime. [Every Weibo endpoint](https://getanyapi.com/api/weibo).

`POST /v1/run/weibo.search`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/89620740-5237-40f5-8e3a-1f5c884e7ae4

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `includeType` | string | No | Media filter, such as all, pic, video, music, or link. |
| `page` | integer | No | Page number starting at 1. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Search keyword. |
| `searchType` | string | No | Search type, such as all, hot, original, verified, media, or viewpoint. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `timeScope` | string | No | Custom time range in the API's custom:start:end format. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/weibo.search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","includeType":"<string>","page":"<integer>","preferLatencyUnderMs":"<integer>","query":"<string>","searchType":"<string>","source":"<string>","timeScope":"<string>"}}'
```

### X / Twitter Trends

Get current X (Twitter) trends for worldwide, a country, or a city in X ranking order, including the resolved location.

**Price:** \$0.10 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [X / Twitter Trends pricing and uptime](https://getanyapi.com/api/x-twitter/trends) - live USD price, lane routing, and measured 30-day uptime. [Every X (Twitter) endpoint](https://getanyapi.com/api/x-twitter).

`POST /v1/run/twitter.trends`

**Cost:** Up to $0.000501 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.000501 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/d147ac59-4162-4e33-9601-576363a3a12f

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum number of ranked trends to return (1-50, default 50). |
| `location` | string | No | Country name, city name, or ISO country code. Omit for worldwide trends. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `promoted`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a trend |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/twitter.trends","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","limit":"<integer>","location":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>"}}'
```

### Twitter Tweet

Fetch a single Twitter/X tweet by URL with its full text and engagement counts (likes, retweets, replies, quotes, bookmarks, views).

**Price:** \$0.22 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 4 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Twitter Tweet pricing and uptime](https://getanyapi.com/api/x-twitter/tweet) - live USD price, lane routing, and measured 30-day uptime. [Every X (Twitter) endpoint](https://getanyapi.com/api/x-twitter).

`POST /v1/run/twitter.tweet`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/0924da88-eef7-42e8-aa27-7dd3d5bafe96

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `videoUrl` or `width`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Canonical x.com or twitter.com status URL with a numeric tweet ID, including /i/web/status and media-share variants. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/twitter.tweet","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>","url":"<string>"}}'
```

### Twitter Tweet Transcript

Extract the spoken transcript from a Twitter/X video tweet by URL.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Twitter Tweet Transcript pricing and uptime](https://getanyapi.com/api/x-twitter/tweet-transcript) - live USD price, lane routing, and measured 30-day uptime. [Every X (Twitter) endpoint](https://getanyapi.com/api/x-twitter).

`POST /v1/run/twitter.tweet_transcript`

**Cost:** Up to $0.03488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.03488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/358a0ca2-d62f-4372-ad26-85211208012a

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Tweet URL of the video to transcribe (e.g. https://x.com/TheoVon/status/1916982720317821050). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/twitter.tweet_transcript","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### X / Twitter User Posts

Get an X (Twitter) account's profile Posts-tab timeline by handle. Results follow profile order: a pinned post may appear first, followed by otherwise reverse-chronological authored posts, reposts, quotes, and self-thread continuations.

**Price:** \$0.45 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [X / Twitter User Posts pricing and uptime](https://getanyapi.com/api/x-twitter/user-posts) - live USD price, lane routing, and measured 30-day uptime. [Every X (Twitter) endpoint](https://getanyapi.com/api/x-twitter).

`POST /v1/run/twitter.user_posts`

**Cost:** Up to $0.002289 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.002289 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/535a40bc-0136-419e-a614-86ff488d8979

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Opaque pagination cursor from a previous response's nextCursor. Omit for the first page. |
| `handle` | string | Yes | Twitter/X handle without the leading @. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `isPinned`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a tweet |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/twitter.user_posts","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","handle":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>"}}'
```

### X / Twitter User Tweets and Replies

Get up to the requested limit of tweets and replies authored by an X (Twitter) account, with engagement, views, language, and cursor pagination where available.

**Price:** \$0.45 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [X / Twitter User Tweets and Replies pricing and uptime](https://getanyapi.com/api/x-twitter/user-tweets) - live USD price, lane routing, and measured 30-day uptime. [Every X (Twitter) endpoint](https://getanyapi.com/api/x-twitter).

`POST /v1/run/twitter.user_tweets`

**Cost:** Up to $0.011009 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.011009 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/ffbe4f17-83c5-41a0-8b40-7b344158c9d4

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Opaque pagination cursor from a previous response's nextCursor. Omit for the first page. |
| `handle` | string | Yes | Twitter/X handle without the leading @. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Page size to ask for (1-100, default 20). Some sources honor it; others always return their whole native page of about 20 authored tweets and replies. A page is never trimmed after the call, so follow nextCursor and pass it back as cursor to continue exactly where this response ended. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `isPinned`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a post t |
| `requireSinglePage` | boolean | No | Require a lane that can return the requested limit in one response. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/twitter.user_tweets","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","handle":"<string>","ignoreSources":"<string>","limit":"<integer>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","requireSinglePage":"<boolean>","source":"<string>"}}'
```

### Unsplash Photo Search

Search Unsplash for free stock photos by keyword. Returns image URLs in several sizes, dimensions, alt text, the photographer's name and profile, and the photo's Unsplash page.

**Price:** billed per result - \$0.55 per 1,000 requests base + \$1.65 per 1,000 results, capped at \$33.60 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Unsplash Photo Search pricing and uptime](https://getanyapi.com/api/unsplash/search-photos) - live USD price, lane routing, and measured 30-day uptime. [Every Unsplash endpoint](https://getanyapi.com/api/unsplash).

`POST /v1/run/unsplash.search_photos`

**Cost:** Up to $0.036624 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.036624 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/ddadea8b-8edc-4f4b-a5e2-3fb33acca121

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `color` | string | No | Only return photos with this dominant color tone. Omit for any color. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum number of photos to return (1-20, default 20). You are billed per photo returned, so a lower limit costs less. |
| `orientation` | string | No | Only return photos with this orientation. Omit for any orientation. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Keyword or phrase to search Unsplash photos for, e.g. "coffee" or "minimal workspace". |
| `sortBy` | string | No | Order results by best match (relevant, the default) or newest first (recent). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/unsplash.search_photos","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","color":"<string>","ignoreSources":"<string>","limit":"<integer>","orientation":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","sortBy":"<string>","source":"<string>"}}'
```

### Upwork Jobs

Search Upwork job postings by keyword, with up to 25 fresh listings per request.

**Price:** \$7.00 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Upwork Jobs pricing and uptime](https://getanyapi.com/api/upwork/jobs) - live USD price, lane routing, and measured 30-day uptime. [Every Upwork endpoint](https://getanyapi.com/api/upwork).

`POST /v1/run/upwork.jobs`

**Cost:** Up to $0.031174 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.031174 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/02519b49-b733-4f83-84f2-ad3b32f136d3

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `experienceLevel` | string | No | Filter by required experience level. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `jobType` | string | No | Filter by payment type: fixed-price or hourly jobs. |
| `limit` | integer | No | Maximum number of results to return (10-25, default 25). |
| `location` | string | No | Filter by client location - a region, subregion, or country (e.g. United States, Europe). |
| `paymentVerified` | boolean | No | When true, only return jobs from clients with a verified payment method. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Keywords to search Upwork jobs for (e.g. react developer). |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `premium` or `reposted`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absen |
| `sort` | string | No | Sort order for listings: newest or relevance (e.g. newest). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/upwork.jobs","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","experienceLevel":"<string>","ignoreSources":"<string>","jobType":"<string>","limit":"<integer>","location":"<string>","paymentVerified":"<boolean>","preferLatencyUnderMs":"<integer>","query":"<string>","requireFields":"<string>","sort":"<string>","source":"<string>"}}'
```

### Vrbo Search

Search Vrbo vacation rentals by destination and dates, with guest, bedroom, bed, bathroom and price filters, and get up to 50 listings per call: Vrbo property ID and link, name, summary line, property type, bedrooms, beds, guest rating and review count, nightly and total stay price with the original nightly price before any discount, and photos as normalized JSON. Page with offset; the price is the same whatever the limit.

**Price:** \$1.00 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Vrbo Search pricing and uptime](https://getanyapi.com/api/vrbo/search) - live USD price, lane routing, and measured 30-day uptime. [Every Vrbo endpoint](https://getanyapi.com/api/vrbo).

`POST /v1/run/vrbo.search`

**Cost:** Up to $0.000927 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.000927 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/abc584e9-787f-4f73-8bdc-8e764532b0ea

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `adults` | integer | No | Number of adult guests (e.g. 2). |
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `checkIn` | string | Yes | Check-in date in YYYY-MM-DD format (e.g. 2027-01-15). Today or later. |
| `checkOut` | string | Yes | Check-out date in YYYY-MM-DD format (e.g. 2027-01-18). After the check-in date. |
| `childrenAges` | integer | No | Age of each child guest, one entry per child (e.g. [5, 8] for two children aged 5 and 8). Omit it when no children are staying. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum number of listings to return (1-50, default 20). The price is the same whatever the limit. |
| `location` | string | Yes | Destination to search rentals in: a city, region or area (e.g. Lake Tahoe, Lisbon, Outer Banks, North Carolina). |
| `minBathrooms` | integer | No | Minimum number of bathrooms (e.g. 2). |
| `minBedrooms` | integer | No | Minimum number of bedrooms (e.g. 3). |
| `minBeds` | integer | No | Minimum number of beds (e.g. 4). |
| `offset` | integer | No | Number of listings to skip, for paging: send offset 20 with limit 20 for the second page. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `priceMax` | integer | No | Maximum price in the currency results are priced in (each listing's currency), per night or for the whole stay as priceType says (e.g. 400). With a price filter, only listings Vrbo prices for your dates are returned. |
| `priceMin` | integer | No | Minimum price in the currency results are priced in (each listing's currency), per night or for the whole stay as priceType says (e.g. 100). |
| `priceType` | string | No | Whether priceMin and priceMax are a nightly price (default) or the total for the stay. |
| `sort` | string | No | Result order: recommended (Vrbo's default), price_low_to_high, price_high_to_low, review (highest rated first) or review_count (most reviewed first). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/vrbo.search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"adults":"<integer>","allowFallbacks":"<boolean>","checkIn":"<string>","checkOut":"<string>","childrenAges":"<integer>","ignoreSources":"<string>","limit":"<integer>","location":"<string>","minBathrooms":"<integer>","minBedrooms":"<integer>","minBeds":"<integer>","offset":"<integer>","preferLatencyUnderMs":"<integer>","priceMax":"<integer>","priceMin":"<integer>","priceType":"<string>","sort":"<string>","source":"<string>"}}'
```

### Walmart Product

Fetch a Walmart product page by URL and get full product details (title, price, availability, ratings, images, and specs) in one normalized response.

**Price:** \$1.00 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 4 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Walmart Product pricing and uptime](https://getanyapi.com/api/walmart/product) - live USD price, lane routing, and measured 30-day uptime. [Every Walmart endpoint](https://getanyapi.com/api/walmart).

`POST /v1/run/walmart.product`

**Cost:** Up to $0.003564 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003564 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/b79ba519-8b6e-4436-83b3-0a4e5fa1e221

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `productId`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a produ |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Walmart product page URL. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/walmart.product","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>","url":"<string>"}}'
```

### Walmart Reviews

Pull a page of 10 customer reviews for any Walmart product by URL, newest first or by relevance, helpfulness, or rating: rating, title, text, date, reviewer, and verified-purchase badge.

**Price:** \$0.85 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Walmart Reviews pricing and uptime](https://getanyapi.com/api/walmart/reviews) - live USD price, lane routing, and measured 30-day uptime. [Every Walmart endpoint](https://getanyapi.com/api/walmart).

`POST /v1/run/walmart.reviews`

**Cost:** Up to $0.002453 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.002453 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/82c8571a-73e3-4d91-971f-aa0341e73ed6

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `page` | integer | No | 1-based page of 10 reviews, Walmart's fixed page size; Walmart serves at most 100 pages. Each page is billed as one request; keep url and sort the same while walking pages. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `totalPages`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. Naming a combination that no single source |
| `sort` | string | No | Review order: recent (newest first, the default), oldest, relevancy, helpful, rating_high, or rating_low (e.g. helpful). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Walmart product page URL (e.g. https://www.walmart.com/ip/Apple-AirPods-Pro-2/5689919121). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/walmart.reviews","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","page":"<integer>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","sort":"<string>","source":"<string>","url":"<string>"}}'
```

### Website Crawl

Crawl a website and get up to 10 of its pages as separate items, each with its URL, title, description, language, HTTP status, clean Markdown text and page metadata such as headings and structured data, ideal for feeding sites into LLMs and search indexes. Pages that failed or were skipped are listed separately and never billed.

**Price:** billed per result - \$1.25 per 1,000 results, capped at \$12.50 per 1,000 requests.

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Website Crawl pricing and uptime](https://getanyapi.com/api/web/crawl) - live USD price, lane routing, and measured 30-day uptime. [Every Web endpoint](https://getanyapi.com/api/web).

`POST /v1/run/web.crawl`

**Cost:** Up to $0.013625 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.013625 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/5537db40-b2c9-478e-b054-e0648e1f940b

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum number of pages to crawl and return (1-10, default 10). You are billed per page returned, so a lower limit costs less. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged. Name the output fields this request must be able to return, for example `language`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. Every source charges the same per page, so this never changes your price. A named field can still be empty on a page that genuinely lacks it. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | The website URL or domain to crawl. Pages linked from it on the same site are crawled too. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/web.crawl","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","limit":"<integer>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>","url":"<string>"}}'
```

### Web Map

Map an entire website into a clean list of its URLs (with titles and descriptions) in a single call.

**Price:** \$1.00 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Web Map pricing and uptime](https://getanyapi.com/api/web/map) - live USD price, lane routing, and measured 30-day uptime. [Every Web endpoint](https://getanyapi.com/api/web).

`POST /v1/run/web.map`

**Cost:** Up to $0.00109 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.00109 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/1d750f69-5c60-4681-98c3-dd31825192d4

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `includeSubdomains` | boolean | No | When true (upstream default), include URLs on subdomains of the target (for example docs.example.com when mapping example.com). Set false to return only URLs on the exact host. |
| `limit` | integer | No | Maximum number of links to return. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `search` | string | No | Optional term that orders the returned links by relevance. |
| `sitemap` | string | No | How to use the site's sitemap.xml when discovering URLs. 'include' (upstream default) merges sitemap URLs with links found by crawling; 'only' returns just the URLs listed in the sitemap (fastest and most authoritative); 'skip' ignores the sitemap and discovers URLs by crawling links. Omit to use 'include'. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | The base URL of the site to map into a list of links. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/web.map","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","includeSubdomains":"<boolean>","limit":"<integer>","preferLatencyUnderMs":"<integer>","search":"<string>","sitemap":"<string>","source":"<string>","url":"<string>"}}'
```

### Web Scrape

Scrape any web page and get its content back as clean Markdown (or HTML, or raw HTML) plus title and metadata.

**Price:** \$0.70 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 6 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Web Scrape pricing and uptime](https://getanyapi.com/api/web/scrape) - live USD price, lane routing, and measured 30-day uptime. [Every Web endpoint](https://getanyapi.com/api/web).

`POST /v1/run/web.scrape`

**Cost:** Up to $0.001635 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001635 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/637c2add-e543-4c40-b8bf-c59255fd9815

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `blockAds` | boolean | No | When true (upstream default), strip ad and cookie-consent elements before capture. Set false to keep them. |
| `excludeTags` | string | No | CSS selectors to drop before capture (for example ["nav", "footer", ".ads"]). Applied after includeTags. |
| `formats` | string | No | Which representations of the page to return. Any combination of: markdown (page content as Markdown), html (the page HTML exactly as the browser received it, including head and script tags). Each requested format is returned under the matching output field. Defaults to both. rawHtml is a deprecated alias of html, returned under a rawHtml field for callers that predate the rename; send html instead. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `includeTags` | string | No | CSS selectors to keep. When set, only content matching these selectors is captured (for example ["article", "main"] or ["#content"]). |
| `mobile` | boolean | No | When true, render the page with a mobile viewport and user agent instead of desktop. Some sites serve materially different content to mobile. |
| `onlyMainContent` | boolean | No | When true, return only the main article content, stripping navigation, headers, footers, and other boilerplate. Defaults to false to capture the full page. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `statusCode`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a reco |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | The full web address of the page to scrape, including its domain, for example https://example.com. The https:// prefix is optional. |
| `waitFor` | integer | No | Milliseconds to wait for the page to finish rendering before capture. Use this for JavaScript-heavy pages or single-page apps whose content loads after the initial paint. Capped at 15000 to stay within the request timeout. This wait is time you asked us to spend, so your response takes this much longer, and it is excluded from the latency published for this endpoint. If every provider that can wait fails, the page may still be returned, captured without the wait. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/web.scrape","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","blockAds":"<boolean>","excludeTags":"<string>","formats":"<string>","ignoreSources":"<string>","includeTags":"<string>","mobile":"<boolean>","onlyMainContent":"<boolean>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>","url":"<string>","waitFor":"<integer>"}}'
```

### Weibo User Posts

List public posts from a Weibo user with normalized author and engagement data.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Weibo User Posts pricing and uptime](https://getanyapi.com/api/weibo/user-posts) - live USD price, lane routing, and measured 30-day uptime. [Every Weibo endpoint](https://getanyapi.com/api/weibo).

`POST /v1/run/weibo.user_posts`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/f26deaff-660d-4fff-98af-9349bff9295e

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Pagination identifier returned as nextCursor. |
| `feature` | integer | No | Response detail feature: 0 basic, 1 extended, 2 image-oriented, or 3 video-oriented. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `page` | integer | No | Page number starting at 1. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `userId` | string | Yes | Weibo user identifier. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/weibo.user_posts","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","feature":"<integer>","ignoreSources":"<string>","page":"<integer>","preferLatencyUnderMs":"<integer>","source":"<string>","userId":"<string>"}}'
```

### Website Screenshot

Capture a real-browser screenshot of any web page URL.

**Price:** \$1.30 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Website Screenshot pricing and uptime](https://getanyapi.com/api/web/screenshot) - live USD price, lane routing, and measured 30-day uptime. [Every Web endpoint](https://getanyapi.com/api/web).

`POST /v1/run/web.screenshot`

**Cost:** Up to $0.001744 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001744 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/17493fda-9086-44cd-b761-bb207c9d0af6

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | The full URL of the page to capture. |
| `viewportWidth` | integer | No | Browser viewport width in pixels (e.g. 1280). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/web.screenshot","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>","viewportWidth":"<integer>"}}'
```

### Weibo Hot Search

Get the complete current Weibo hot-search ranking with labels and heat values.

**Price:** \$1.80 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Weibo Hot Search pricing and uptime](https://getanyapi.com/api/weibo/hot-search) - live USD price, lane routing, and measured 30-day uptime. [Every Weibo endpoint](https://getanyapi.com/api/weibo).

`POST /v1/run/weibo.hot_search`

**Cost:** Up to $0.001962 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001962 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/ff6670a7-ed16-4549-85b0-7685b524291a

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/weibo.hot_search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### Weibo Post

Fetch a public Weibo post by ID with normalized author and engagement data.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Weibo Post pricing and uptime](https://getanyapi.com/api/weibo/post) - live USD price, lane routing, and measured 30-day uptime. [Every Weibo endpoint](https://getanyapi.com/api/weibo).

`POST /v1/run/weibo.post`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/77433c11-f8de-4051-bee2-7ebe0469b971

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `includeLongText` | string | No | Whether to include the full text of long posts. |
| `postId` | string | Yes | Weibo post identifier. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/weibo.post","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","includeLongText":"<string>","postId":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### Weibo Post Comments

List first-level comments on a public Weibo post with pagination.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Weibo Post Comments pricing and uptime](https://getanyapi.com/api/weibo/post-comments) - live USD price, lane routing, and measured 30-day uptime. [Every Weibo endpoint](https://getanyapi.com/api/weibo).

`POST /v1/run/weibo.post_comments`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/7e1e5cec-42fb-4fc0-8bcf-8f3189c59f7f

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Pagination cursor returned as nextCursor. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Requested comment count. |
| `postId` | string | Yes | Weibo post identifier. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/weibo.post_comments","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","ignoreSources":"<string>","limit":"<integer>","postId":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### Weibo Profile

Fetch a public Weibo profile by user ID with normalized audience and account data.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Weibo Profile pricing and uptime](https://getanyapi.com/api/weibo/profile) - live USD price, lane routing, and measured 30-day uptime. [Every Weibo endpoint](https://getanyapi.com/api/weibo).

`POST /v1/run/weibo.profile`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/c24b9e87-4de6-4dc7-a7b9-7a7eb11d74eb

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `userId` | string | Yes | Weibo user identifier. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/weibo.profile","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","userId":"<string>"}}'
```

### Yahoo Finance Quote

Look up a stock or ETF by ticker symbol and get its Yahoo Finance quote (price, market cap, volume, and key stats) as normalized JSON.

**Price:** billed per result - \$0.06 per 1,000 requests base + \$0.99 per 1,000 results, capped at \$1.05 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Yahoo Finance Quote pricing and uptime](https://getanyapi.com/api/yahoo-finance/quote) - live USD price, lane routing, and measured 30-day uptime. [Every Yahoo Finance endpoint](https://getanyapi.com/api/yahoo-finance).

`POST /v1/run/yahoo_finance.quote`

**Cost:** Up to $0.001145 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001145 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/dba355b3-473d-4dfb-ba99-9df53b45f55f

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `ticker` | string | Yes | The ticker symbol to look up. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/yahoo_finance.quote","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","ticker":"<string>"}}'
```

### Yelp Search

Search Yelp for businesses by keyword and location: up to 20 listings with ratings, categories, and core business info per request.

**Price:** \$3.50 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Yelp Search pricing and uptime](https://getanyapi.com/api/yelp/search) - live USD price, lane routing, and measured 30-day uptime. [Every Yelp endpoint](https://getanyapi.com/api/yelp).

`POST /v1/run/yelp.search`

**Cost:** Up to $0.029975 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.029975 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/3c1b0ae0-04c2-4632-9772-b474cbcc695b

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum number of results to return (1 to 20, default 20). |
| `location` | string | Yes | City and state defining the search area (e.g. San Francisco, CA). |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Search term or category to look for (e.g. sushi). |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `is_closed` or `price`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/yelp.search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","limit":"<integer>","location":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","requireFields":"<string>","source":"<string>"}}'
```

### YouTube Channel

Fetch a YouTube channel's stats (subscribers, video count, total views, description) and the links on its About page, by handle or channel ID.

**Price:** \$0.45 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 5 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [YouTube Channel pricing and uptime](https://getanyapi.com/api/youtube/channel) - live USD price, lane routing, and measured 30-day uptime. [Every YouTube endpoint](https://getanyapi.com/api/youtube).

`POST /v1/run/youtube.channel`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/2c3c9039-8d8b-4a9a-8ccf-f95c6539aa0c

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `channelId` | string | No | YouTube channel ID (UC...). Pass it directly when you have it: some sources accept only the ID and otherwise look up the handle first, which adds a step. |
| `handle` | string | No | YouTube channel handle. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `views`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a record th |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/youtube.channel","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","channelId":"<string>","handle":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>"}}'
```

### YouTube Channel Community Posts

List a YouTube channel's community posts by handle or channel ID with cursor pagination (text, likes, image, publish time).

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [YouTube Channel Community Posts pricing and uptime](https://getanyapi.com/api/youtube/channel-community-posts) - live USD price, lane routing, and measured 30-day uptime. [Every YouTube endpoint](https://getanyapi.com/api/youtube).

`POST /v1/run/youtube.channel_community_posts`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/f7e16b7b-bc40-4b3b-94f7-2d02d119bb5d

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `channelId` | string | No | YouTube channel ID. |
| `cursor` | string | No | Continuation token from a previous response for pagination. |
| `handle` | string | No | YouTube channel handle. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/youtube.channel_community_posts","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","channelId":"<string>","cursor":"<string>","handle":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### YouTube Channel Live Streams

List a YouTube channel's live and past-live streams by handle or channel ID with cursor pagination (title, views, length, publish time).

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [YouTube Channel Live Streams pricing and uptime](https://getanyapi.com/api/youtube/channel-lives) - live USD price, lane routing, and measured 30-day uptime. [Every YouTube endpoint](https://getanyapi.com/api/youtube).

`POST /v1/run/youtube.channel_lives`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/3167ba8f-e77a-40d2-b3d9-b298a4bff617

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `channelId` | string | No | YouTube channel ID. |
| `cursor` | string | No | Continuation token from a previous response for pagination. |
| `handle` | string | No | YouTube channel handle. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `lengthText`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a live |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/youtube.channel_lives","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","channelId":"<string>","cursor":"<string>","handle":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>"}}'
```

### YouTube Channel Playlists

List a YouTube channel's playlists by handle or channel ID with cursor pagination (title, video count, thumbnail).

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [YouTube Channel Playlists pricing and uptime](https://getanyapi.com/api/youtube/channel-playlists) - live USD price, lane routing, and measured 30-day uptime. [Every YouTube endpoint](https://getanyapi.com/api/youtube).

`POST /v1/run/youtube.channel_playlists`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/4cdd5d06-2b24-4d89-a1dc-c6a4df8ad1ed

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `channelId` | string | No | YouTube channel ID. |
| `cursor` | string | No | Continuation token from a previous response for pagination. |
| `handle` | string | No | YouTube channel handle. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/youtube.channel_playlists","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","channelId":"<string>","cursor":"<string>","handle":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### YouTube Channel Public Email

Get the email address a YouTube creator writes in the channel's public description, the text anyone can read on the About tab. It never returns the business email YouTube hides behind the View email address button; youtube.channel_contact reveals that one.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [YouTube Channel Public Email pricing and uptime](https://getanyapi.com/api/youtube/channel-public-email) - live USD price, lane routing, and measured 30-day uptime. [Every YouTube endpoint](https://getanyapi.com/api/youtube).

`POST /v1/run/youtube.channel_public_email`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/3fd39554-d601-4cfc-81f5-657305a01a16

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `channelId` | string | No | YouTube channel ID (UC...). |
| `handle` | string | No | YouTube channel handle, with or without the leading @. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/youtube.channel_public_email","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","channelId":"<string>","handle":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### YouTube Channel Shorts

List a YouTube channel's Shorts by handle or channel ID with cursor pagination, views, and publish timestamps.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [YouTube Channel Shorts pricing and uptime](https://getanyapi.com/api/youtube/channel-shorts) - live USD price, lane routing, and measured 30-day uptime. [Every YouTube endpoint](https://getanyapi.com/api/youtube).

`POST /v1/run/youtube.channel_shorts`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/00c3a8be-b88b-433f-9e90-3e13d927bc05

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `channelId` | string | No | YouTube channel ID beginning with UC. |
| `cursor` | string | No | Continuation token from a previous response. |
| `handle` | string | No | YouTube channel handle, including or omitting the leading @. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `sort` | string | No | Sort order for the Shorts feed. latest and newest are equivalent. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/youtube.channel_shorts","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","channelId":"<string>","cursor":"<string>","handle":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","sort":"<string>","source":"<string>"}}'
```

### YouTube Channel Videos

List a YouTube channel's videos by handle or channel ID with cursor pagination (title, views, length, publish time).

**Price:** \$0.80 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [YouTube Channel Videos pricing and uptime](https://getanyapi.com/api/youtube/channel-videos) - live USD price, lane routing, and measured 30-day uptime. [Every YouTube endpoint](https://getanyapi.com/api/youtube).

`POST /v1/run/youtube.channel_videos`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/ede0d523-5277-4a80-8658-f838794045ef

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `channelId` | string | No | YouTube channel ID. |
| `cursor` | string | No | Continuation token from a previous response for pagination. |
| `handle` | string | No | YouTube channel handle. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `views`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a video tha |
| `sort` | string | No | Sort order. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/youtube.channel_videos","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","channelId":"<string>","cursor":"<string>","handle":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","sort":"<string>","source":"<string>"}}'
```

### YouTube Comment Replies

List replies to a YouTube comment using a continuation token with cursor pagination (text, author, likes, publish time).

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [YouTube Comment Replies pricing and uptime](https://getanyapi.com/api/youtube/comment-replies) - live USD price, lane routing, and measured 30-day uptime. [Every YouTube endpoint](https://getanyapi.com/api/youtube).

`POST /v1/run/youtube.comment_replies`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/9249e183-81bf-4bfd-9459-b0fd5aea1dae

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `continuationToken` | string | Yes | Replies continuation token from the comments endpoint, or the continuationToken from a previous replies response for further pagination. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/youtube.comment_replies","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","continuationToken":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### YouTube Community Post

Fetch a single YouTube community post by URL (text, images, channel, publish time).

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [YouTube Community Post pricing and uptime](https://getanyapi.com/api/youtube/community-post) - live USD price, lane routing, and measured 30-day uptime. [Every YouTube endpoint](https://getanyapi.com/api/youtube).

`POST /v1/run/youtube.community_post`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/d02dbd54-978d-495c-91ae-ab62d98368b5

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | URL of the YouTube community post. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/youtube.community_post","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### YouTube Playlist

List every video in a YouTube playlist (title, length, and channel per video plus playlist owner and totals).

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [YouTube Playlist pricing and uptime](https://getanyapi.com/api/youtube/playlist) - live USD price, lane routing, and measured 30-day uptime. [Every YouTube endpoint](https://getanyapi.com/api/youtube).

`POST /v1/run/youtube.playlist`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/405b853a-567f-4083-9201-048551d01657

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `playlistId` | string | Yes | The playlist ID: the "list" parameter in a playlist URL (e.g. "PLu0W_9lII9ahIappRPN0MCAgtOu3lQjQi"). |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/youtube.playlist","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","playlistId":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### YouTube Search

Search YouTube and get matching videos (title, channel, views, length, publish time) as normalized JSON.

**Price:** \$0.50 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [YouTube Search pricing and uptime](https://getanyapi.com/api/youtube/search) - live USD price, lane routing, and measured 30-day uptime. [Every YouTube endpoint](https://getanyapi.com/api/youtube).

`POST /v1/run/youtube.search`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/45617a6e-4f3b-4bf9-9991-c450dbcf4f81

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Continuation token from a previous response for pagination. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | The YouTube search query. |
| `requireCursor` | boolean | No | Deprecated; send `requireFields: ["nextCursor"]` instead, which does exactly the same thing. Set true if you intend to page through results, so the request is only served by a source that can return a nextCursor. Omit it and routing is unchanged, with the cheapest source serving. This can raise your price: when the cheapest source cannot page, a source that can serves, and you are quoted and charged its price. It stays accepted so callers that already send it keep working. |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `nextCursor`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a resu |
| `sortBy` | string | No | Sort order: "relevance" (default) or "popular" (most-viewed). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `uploadDate` | string | No | Filter by upload recency. Omit for any time. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/youtube.search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","requireCursor":"<boolean>","requireFields":"<string>","sortBy":"<string>","source":"<string>","uploadDate":"<string>"}}'
```

### YouTube Hashtag Search

Search YouTube videos by hashtag with cursor pagination (title, channel, views, length, publish time).

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [YouTube Hashtag Search pricing and uptime](https://getanyapi.com/api/youtube/search-hashtag) - live USD price, lane routing, and measured 30-day uptime. [Every YouTube endpoint](https://getanyapi.com/api/youtube).

`POST /v1/run/youtube.search_hashtag`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/0114b8c2-4567-487a-ad76-2157bbfbac6b

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Continuation token from a previous response for pagination. |
| `hashtag` | string | Yes | Hashtag to search for (without the leading #). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `type` | string | No | Content filter. Only "all" is served: no source we buy returns a Shorts row with the channel and publish time this endpoint requires. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/youtube.search_hashtag","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","hashtag":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","type":"<string>"}}'
```

### YouTube Shorts Search

Search YouTube Shorts by keyword and get matching Shorts (title, views, URL) with cursor pagination as normalized JSON.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [YouTube Shorts Search pricing and uptime](https://getanyapi.com/api/youtube/search-shorts) - live USD price, lane routing, and measured 30-day uptime. [Every YouTube endpoint](https://getanyapi.com/api/youtube).

`POST /v1/run/youtube.search_shorts`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/ebd7a108-7eef-4071-bcd1-f0994eced5b9

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Continuation token from a previous response for pagination. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | The keyword to search Shorts for. |
| `sortBy` | string | No | Sort order: "relevance" (default) or "popular" (most-viewed). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `uploadDate` | string | No | Filter by upload recency. Omit for any time. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/youtube.search_shorts","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","sortBy":"<string>","source":"<string>","uploadDate":"<string>"}}'
```

### YouTube Trending Shorts

List currently trending YouTube Shorts (title, channel, views, likes, duration).

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [YouTube Trending Shorts pricing and uptime](https://getanyapi.com/api/youtube/trending-shorts) - live USD price, lane routing, and measured 30-day uptime. [Every YouTube endpoint](https://getanyapi.com/api/youtube).

`POST /v1/run/youtube.trending_shorts`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/a8d74a4d-30af-448a-abd0-ec36452d9dbf

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/youtube.trending_shorts","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### YouTube Video

Fetch a YouTube video or Short's metadata (title, channel, views, likes, duration, publish date) by URL or ID.

**Price:** \$0.80 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [YouTube Video pricing and uptime](https://getanyapi.com/api/youtube/video) - live USD price, lane routing, and measured 30-day uptime. [Every YouTube endpoint](https://getanyapi.com/api/youtube).

`POST /v1/run/youtube.video`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/6dbbe792-0d8e-4ac6-9c5d-9f74a2bb1bdb

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `id` | string | No | YouTube video ID. A Short uses the same ID as any other video. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `authorAvatarUrl`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | No | Full YouTube video URL. Shorts (youtube.com/shorts/...), youtu.be, live, and embed URLs all work. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/youtube.video","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","id":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>","url":"<string>"}}'
```

### YouTube Video Comments

List the comments on a YouTube video or Short by URL with cursor pagination (text, author, likes, reply count).

**Price:** \$0.80 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 4 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [YouTube Video Comments pricing and uptime](https://getanyapi.com/api/youtube/video-comments) - live USD price, lane routing, and measured 30-day uptime. [Every YouTube endpoint](https://getanyapi.com/api/youtube).

`POST /v1/run/youtube.video_comments`

**Cost:** Up to $0.003488 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.003488 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/a255b415-07ad-48fe-a7b7-fa4a6751d54b

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Continuation token from a previous response for pagination. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `order` | string | No | Comment order (e.g. top, newest). |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `likes`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. On a paginated walk it applies to the first page |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Full YouTube video URL. Shorts (youtube.com/shorts/...) and youtu.be URLs also work. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/youtube.video_comments","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","ignoreSources":"<string>","order":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>","url":"<string>"}}'
```

### YouTube Video Sponsors

Detect suspected sponsors and paid promotions in a YouTube video by URL (sponsor names, websites, confidence).

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [YouTube Video Sponsors pricing and uptime](https://getanyapi.com/api/youtube/video-sponsors) - live USD price, lane routing, and measured 30-day uptime. [Every YouTube endpoint](https://getanyapi.com/api/youtube).

`POST /v1/run/youtube.video_sponsors`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/73bc4ee8-2384-42fe-ad35-32e4f162102d

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `language` | string | No | 2-letter language code for transcript lookup (e.g. en, es, fr). |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | YouTube video or Short URL. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/youtube.video_sponsors","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","language":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### YouTube Video Transcript

Fetch the transcript/captions of a YouTube video or Short by URL or ID.

**Price:** \$0.90 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 5 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [YouTube Video Transcript pricing and uptime](https://getanyapi.com/api/youtube/video-transcript) - live USD price, lane routing, and measured 30-day uptime. [Every YouTube endpoint](https://getanyapi.com/api/youtube).

`POST /v1/run/youtube.video_transcript`

**Cost:** Up to $0.010464 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.010464 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/4ebf8bac-c601-4362-83f2-dd7601ad61ec

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `id` | string | No | YouTube video ID. A Short uses the same ID as any other video. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | No | Full YouTube video URL. Shorts (youtube.com/shorts/...), youtu.be, live, and embed URLs all work. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/youtube.video_transcript","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","id":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### YouTube Video Transcript (Provenance)

Fetch a YouTube video or Short transcript with timed segments and its provenance: whether the words are creator-written captions or machine speech recognition.

**Price:** \$2.00 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [YouTube Video Transcript (Provenance) pricing and uptime](https://getanyapi.com/api/youtube/video-transcript-full) - live USD price, lane routing, and measured 30-day uptime. [Every YouTube endpoint](https://getanyapi.com/api/youtube).

`POST /v1/run/youtube.video_transcript_full`

**Cost:** Up to $0.00291 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.00291 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/ccb6560c-8dd1-483f-969c-8abad1498b34

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `captionKind` | string | No | Which caption track to accept: "manual" only creator-written captions, "automatic" only YouTube's speech recognition, "any" whichever exists. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `language` | string | No | Preferred caption language code (e.g. "en", "es"). Defaults to English. If the video has no captions in that language, you get the transcript in another language the video has; the `language` field in the result says which. With `captionKind` set to "manual" or "automatic", no other language is returned. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `views`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a transcrip |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | YouTube video or Short URL (e.g. "https://www.youtube.com/watch?v=dQw4w9WgXcQ" or "https://www.youtube.com/shorts/Fir1x9cw2vg"). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/youtube.video_transcript_full","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","captionKind":"<string>","ignoreSources":"<string>","language":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>","url":"<string>"}}'
```

### Zhihu Question Answers

List the first page of public answers to a Zhihu question with normalized authors and engagement data. Pagination is not supported.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Zhihu Question Answers pricing and uptime](https://getanyapi.com/api/zhihu/question-answers) - live USD price, lane routing, and measured 30-day uptime. [Every Zhihu endpoint](https://getanyapi.com/api/zhihu).

`POST /v1/run/zhihu.question_answers`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/3576a283-bff9-4a37-b5a1-3a343ea0e24b

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Number of answers requested on the first page. Pagination is not supported. |
| `order` | string | No | Answer ordering: default ranking or recently updated. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `questionId` | string | Yes | Zhihu question identifier. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/zhihu.question_answers","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","limit":"<integer>","order":"<string>","preferLatencyUnderMs":"<integer>","questionId":"<string>","source":"<string>"}}'
```

### Zhihu Article Search

Search public Zhihu articles by keyword with normalized author and engagement data.

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Zhihu Article Search pricing and uptime](https://getanyapi.com/api/zhihu/search-articles) - live USD price, lane routing, and measured 30-day uptime. [Every Zhihu endpoint](https://getanyapi.com/api/zhihu).

`POST /v1/run/zhihu.search_articles`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/bf60521e-fc1d-4b89-809c-8f12045cc161

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | string | No | Number of articles requested per page. |
| `offset` | string | No | Result offset returned as nextOffset in the previous response. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Search keyword. |
| `searchHashId` | string | No | Search hash identifier returned in the previous response. |
| `showAllTopics` | integer | No | Whether to include all topics: 0 excludes them and 1 includes them. |
| `sort` | string | No | Article ordering: comprehensive, most upvoted, or newest. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `timeInterval` | string | No | Optional publication-time filter. |
| `verticalInfo` | string | No | Article-search vertical continuation state returned as nextVerticalInfo in the previous response. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/zhihu.search_articles","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","limit":"<string>","offset":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","searchHashId":"<string>","showAllTopics":"<integer>","sort":"<string>","source":"<string>","timeInterval":"<string>","verticalInfo":"<string>"}}'
```

### Zillow Property

Fetch full details for a single Zillow property listing by URL (price, facts and features, photos, and price/tax history).

**Price:** \$0.80 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Zillow Property pricing and uptime](https://getanyapi.com/api/zillow/property) - live USD price, lane routing, and measured 30-day uptime. [Every Zillow endpoint](https://getanyapi.com/api/zillow).

`POST /v1/run/zillow.property`

**Cost:** Up to $0.002878 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.002878 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/ecaf8239-01fd-47d5-8386-3830279dc12e

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Zillow property details URL (e.g. https://www.zillow.com/homedetails/123-Main-St-Anytown-CA-90210/12345678_zpid/). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/zillow.property","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### Zillow Search

Search Zillow for-sale, rental, or sold listings by region-level location (city, ZIP, county, or neighborhood) with optional price, bedroom, living-area, home-type, recency, and sort filters and get matching properties (price, address, beds, baths, living area, status, Zestimate) as normalized JSON.

**Price:** \$0.80 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 4 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Zillow Search pricing and uptime](https://getanyapi.com/api/zillow/search) - live USD price, lane routing, and measured 30-day uptime. [Every Zillow endpoint](https://getanyapi.com/api/zillow).

`POST /v1/run/zillow.search`

**Cost:** Up to $0.060277 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.060277 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/2255870c-9618-44f3-b18b-25f04e7ecaa3

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `daysOnZillow` | string | No | Only include listings on Zillow at most this long (e.g. 1_week). |
| `homeTypes` | string | No | Filter by property type; omit for any. Rentals support only singleFamily, multiFamily, townhome, and condo (e.g. ["singleFamily", "condo"]). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `includeAcceptingBackupOffers` | boolean | No | Include listings accepting backup offers, which Zillow excludes by default (e.g. true). |
| `includePendingAndUnderContract` | boolean | No | Include pending and under-contract listings, which Zillow excludes by default (e.g. true). |
| `includeRoomForRent` | boolean | No | Include room-for-rent listings in rent searches; when omitted or false only entire places are returned (e.g. true). |
| `limit` | integer | No | Maximum number of results to return (1-25, default 25). |
| `listingTypes` | string | No | Listing types to include for buy searches; omit for all standard types. fsba = agent listed, fsbo = for sale by owner. Ignored for rent and sold (e.g. ["newConstruction"]). |
| `location` | string | Yes | Region-level location to search: ZIP code, city and state, county, or neighborhood (e.g. 'Austin, TX' or '78701'). Street addresses are not supported; use the property's ZIP code instead. |
| `maxBedrooms` | integer | No | Maximum number of bedrooms (e.g. 5). |
| `maxLivingAreaSqft` | integer | No | Maximum living area in square feet (e.g. 3000). |
| `maxPrice` | integer | No | Maximum price in USD: monthly rent for rentals, total price for buy/sold (e.g. 750000). |
| `minBedrooms` | integer | No | Minimum number of bedrooms (e.g. 3). |
| `minLivingAreaSqft` | integer | No | Minimum living area in square feet (e.g. 1500). |
| `minPrice` | integer | No | Minimum price in USD: monthly rent for rentals, total price for buy/sold (e.g. 250000). |
| `operation` | string | No | Listing type: buy (for sale), rent, or sold. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `yearBuilt`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a listi |
| `showOnlyPriceReductions` | boolean | No | Only show listings with a price reduction. Buy searches only; ignored for rentals (e.g. true). |
| `sortBy` | string | No | Sort order for results; omit for Zillow's default relevance. rentalPriorityScore applies to rent searches only (e.g. newest). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/zillow.search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","daysOnZillow":"<string>","homeTypes":"<string>","ignoreSources":"<string>","includeAcceptingBackupOffers":"<boolean>","includePendingAndUnderContract":"<boolean>","includeRoomForRent":"<boolean>","limit":"<integer>","listingTypes":"<string>","location":"<string>","maxBedrooms":"<integer>","maxLivingAreaSqft":"<integer>","maxPrice":"<integer>","minBedrooms":"<integer>","minLivingAreaSqft":"<integer>","minPrice":"<integer>","operation":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","showOnlyPriceReductions":"<boolean>","sortBy":"<string>","source":"<string>"}}'
```

### Vrbo Listing

Get one Vrbo vacation rental by its property ID: name, link, address, coordinates, bedrooms, bathrooms, beds and guest capacity, guest rating with category scores and review count, amenities by group, full description, house rules, important information, availability and price for your dates (total and average per night, fees included), every photo with its caption and the latest guest reviews, as normalized JSON. Takes the id vrbo.search returns.

**Price:** \$0.85 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Vrbo Listing pricing and uptime](https://getanyapi.com/api/vrbo/listing) - live USD price, lane routing, and measured 30-day uptime. [Every Vrbo endpoint](https://getanyapi.com/api/vrbo).

`POST /v1/run/vrbo.listing`

**Cost:** Up to $0.000927 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.000927 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/edbd0755-ac8d-43a2-b236-a16ac1a8a235

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `adults` | integer | No | Number of adult guests to price for (1-20, default 2). |
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `checkIn` | string | No | Check-in date to price and check availability for, in YYYY-MM-DD format (e.g. 2027-01-15). Today or later. Without dates, a 3-night stay about a month ahead is priced; the dates used are in stay. |
| `checkOut` | string | No | Check-out date in YYYY-MM-DD format (e.g. 2027-01-18). After the check-in date. With a check-in date alone, the stay is 3 nights. |
| `childrenAges` | integer | No | Age of each child guest, one entry per child (e.g. [5, 8] for two children aged 5 and 8). Omit it when no children are staying. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `propertyId` | string | Yes | Vrbo property ID: the id vrbo.search returns for a listing (e.g. 69764328). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/vrbo.listing","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"adults":"<integer>","allowFallbacks":"<boolean>","checkIn":"<string>","checkOut":"<string>","childrenAges":"<integer>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","propertyId":"<string>","source":"<string>"}}'
```

### Google Resolve Links

Turn Google redirect links (google.com/goto?url=...) into the destination URLs they point to. Google search, video, jobs and AI Overview results carry such a link in place of the destination when Google withholds it. Send up to 100 links in one call and get each one back in the order sent, with its destination, or resolved false when Google would not reveal it. One price per call whatever the number of links; a call usually answers in under 30 seconds and can take about a minute.

**Price:** \$0.09 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Google Resolve Links pricing and uptime](https://getanyapi.com/api/google/resolve-links) - live USD price, lane routing, and measured 30-day uptime. [Every Google endpoint](https://getanyapi.com/

`POST /v1/run/google.resolve_links`

**Cost:** Up to $0.000545 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.000545 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/85bd27a4-3d02-4c3c-8740-113c256de826

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `urls` | string | Yes | Google redirect links to resolve, as Google search, video, jobs or AI Overview results return them: https://www.google.com/goto?url=... or https://google.com/goto?url=.... |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/google.resolve_links","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","urls":"<string>"}}'
```

### Google Flights Price Calendar

Get the Google Flights price calendar for a route: the lowest fare for every departure date across a window of up to 120 days, one way or as a round trip of a fixed length, with the return date of each round trip, a flag on every date within 5% of the cheapest, and the cheapest date of the window, as normalized JSON. Choose cabin class, adults and currency. Prices are the total for all passengers; dates with no fare are left out.

**Price:** \$0.85 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Google Flights Price Calendar pricing and uptime](https://getanyapi.com/api/google-flights/calendar) - live USD price, lane routing, and measured 30-day uptime. [Every Google_flights endpoint](https://getanyapi.com/api/google-flights).

`POST /v1/run/google_flights.calendar`

**Cost:** Up to $0.000927 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.000927 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/950462b8-6001-4bf7-b0ba-62cab83903cd

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `adults` | integer | No | Number of adult passengers (1-9, default 1). Prices are for all passengers together. Child passengers cannot be priced on the calendar. |
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cabinClass` | string | No | Cabin class (default economy). |
| `currency` | string | No | ISO 4217 currency code for prices (e.g. USD, EUR, GBP; default USD). |
| `departureDateFrom` | string | Yes | First departure date of the calendar in YYYY-MM-DD format (e.g. 2027-01-12). Today or later. |
| `departureDateTo` | string | Yes | Last departure date of the calendar in YYYY-MM-DD format (e.g. 2027-02-10). At most 120 days after departureDateFrom. |
| `destination` | string | Yes | Arrival airport as a three-letter IATA code in capitals (e.g. LHR), or a Google place ID for a city to cover all of its airports (e.g. /m/04jpl for London). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `origin` | string | Yes | Departure airport as a three-letter IATA code in capitals (e.g. JFK), or a Google place ID for a city to cover all of its airports (e.g. /m/02_286 for New York). |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `tripLengthDays` | integer | No | For a round trip, the number of days between departure and return (1-30, e.g. 7): each date is then priced as a round trip returning that many days later. Omit it for one way. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/google_flights.calendar","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"adults":"<integer>","allowFallbacks":"<boolean>","cabinClass":"<string>","currency":"<string>","departureDateFrom":"<string>","departureDateTo":"<string>","destination":"<string>","ignoreSources":"<string>","origin":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","tripLengthDays":"<integer>"}}'
```

### Instagram User Reels (Logged In)

List an Instagram account's reels by handle as a logged-in Instagram viewer sees them, with cursor pagination: everything instagram.user_reels returns plus saves, reposts, the caption-track URL and, for reels cross-posted to Facebook, the Facebook views, likes and comments. Views, likes and comments are Instagram-only; the Facebook figures are reported separately.

**Price:** \$1.73 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Instagram User Reels (Logged In) pricing and uptime](https://getanyapi.com/api/instagram/user-reels-logged-in) - live USD price, lane routing, and measured 30-day uptime. [Every Instagram endpoint](https://getanyapi.com/api/instagram).

`POST /v1/run/instagram.user_reels_logged_in`

**Cost:** Up to $0.002049 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.002049 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/b6a1a180-b9b5-4005-9ed2-d6aeb5877730

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Pagination cursor (max_id) from a previous response's nextCursor. |
| `handle` | string | No | Instagram handle. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `locationName`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a re |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `userId` | string | No | Instagram user id (faster than handle when known). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/instagram.user_reels_logged_in","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","handle":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>","userId":"<string>"}}'
```

### AliExpress Reviews

Get one page of buyer reviews for an AliExpress product by id, with rating, text, buyer country, date, bought variant and photos for each review, plus the product's total reviews, average rating and star distribution, in one normalized response.

**Price:** \$0.85 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [AliExpress Reviews pricing and uptime](https://getanyapi.com/api/aliexpress/reviews) - live USD price, lane routing, and measured 30-day uptime. [Every Aliexpress endpoint](https://getanyapi.com/api/aliexpress).

`POST /v1/run/aliexpress.reviews`

**Cost:** Up to $0.001166 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001166 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/d22892a7-8a73-4ef5-aa11-9ffa4d4279b1

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `page` | integer | No | 1-based page of 20 reviews in AliExpress's default order. Each page is billed as one request. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `productId` | string | Yes | AliExpress product id, the number in the product URL (https://www.aliexpress.com/item/<id>.html), e.g. 3256807039224587. The AliExpress Search SKU returns it as productId. |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `helpfulVotes`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. Naming a combination that no single sourc |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/aliexpress.reviews","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","page":"<integer>","preferLatencyUnderMs":"<integer>","productId":"<string>","requireFields":"<string>","source":"<string>"}}'
```

### AliExpress Search

Search AliExpress by keyword with optional sort, price-range, page, ship-to country and currency, and get title, price, original price, units sold and image for each product in one normalized response.

**Price:** \$0.85 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [AliExpress Search pricing and uptime](https://getanyapi.com/api/aliexpress/search) - live USD price, lane routing, and measured 30-day uptime. [Every Aliexpress endpoint](https://getanyapi.com/api/aliexpress).

`POST /v1/run/aliexpress.search`

**Cost:** Up to $0.001166 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001166 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/57310954-eac7-4baa-910f-cfce1b4eca22

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `country` | string | No | Ship-to country as a 2-letter ISO code, e.g. US or DE. It changes prices, availability and delivery estimates. |
| `currency` | string | No | Price currency as a 3-letter ISO code, e.g. USD or EUR. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `maxPrice` | number | No | Optional maximum product price, in the requested currency. |
| `minPrice` | number | No | Optional minimum product price, in the requested currency. |
| `page` | integer | No | 1-based results page of about 60 products; AliExpress serves no results past page 60. Each page is billed as one request. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Search keywords, e.g. "wireless earbuds". |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `shipFrom`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. Naming a combination that no single source re |
| `sort` | string | No | Result order: best_match (AliExpress relevance, the default), best_seller (most orders first), price_low, or price_high. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/aliexpress.search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","country":"<string>","currency":"<string>","ignoreSources":"<string>","maxPrice":"<number>","minPrice":"<number>","page":"<integer>","preferLatencyUnderMs":"<integer>","query":"<string>","requireFields":"<string>","sort":"<string>","source":"<string>"}}'
```

### Amazon Deals

List today's Amazon deals for one marketplace and get ASIN, title, deal price, list price, discount, deal type, badge and image for each deal in one normalized response.

**Price:** \$0.85 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Amazon Deals pricing and uptime](https://getanyapi.com/api/amazon/deals) - live USD price, lane routing, and measured 30-day uptime. [Every Amazon endpoint](https://getanyapi.com/api/amazon).

`POST /v1/run/amazon.deals`

**Cost:** Up to $0.001166 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001166 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/49892ea6-d9d7-4157-a45a-ea6e24d061d6

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `region` | string | No | Amazon marketplace to read, as its domain (e.g. amazon.co.uk); omit it for amazon.com. |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `discountPercent`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/amazon.deals","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","region":"<string>","requireFields":"<string>","source":"<string>"}}'
```

### Amazon Offers

List every offer for one Amazon product by ASIN or product URL, the Buy Box first and then the other sellers, and get price, condition, seller name and ID, seller rating, Prime, delivery estimate and fulfillment for each in one normalized response.

**Price:** \$0.85 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Amazon Offers pricing and uptime](https://getanyapi.com/api/amazon/offers) - live USD price, lane routing, and measured 30-day uptime. [Every Amazon endpoint](https://getanyapi.com/api/amazon).

`POST /v1/run/amazon.offers`

**Cost:** Up to $0.001755 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001755 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/a48f9f4f-f676-4c7d-a179-e23a88dd68f7

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `page` | integer | No | 1-based page of the other sellers' offers, about 10 a page; page 1 also carries the Buy Box. Each page is billed as one request. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `product` | string | Yes | Amazon product ASIN (e.g. B006MIWDCC) or a product link on one of the marketplaces listed under region, such as https://www.amazon.co.uk/dp/<ASIN>, with the ASIN after /dp/, /gp/product/ or /product-reviews/. A link without an ASIN, such as a search results page (/s?k=...), or a link to another site or marketplace is refused as invalid input, with no charge. |
| `region` | string | No | Amazon marketplace the product ASIN belongs to (e.g. amazon.co.uk); a product URL sets it from its own domain. |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `sellerId`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a offer |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/amazon.offers","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","page":"<integer>","preferLatencyUnderMs":"<integer>","product":"<string>","region":"<string>","requireFields":"<string>","source":"<string>"}}'
```

### Amazon Seller

Look up one Amazon seller by seller ID and get its name, star rating, positive feedback percentage, feedback counts for the last 30 days, 90 days, 12 months and lifetime, and its registered business name and address in one normalized response.

**Price:** \$0.85 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Amazon Seller pricing and uptime](https://getanyapi.com/api/amazon/seller) - live USD price, lane routing, and measured 30-day uptime. [Every Amazon endpoint](https://getanyapi.com/api/amazon).

`POST /v1/run/amazon.seller`

**Cost:** Up to $0.001166 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001166 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/e916ae94-4915-46fa-ad3a-b25510b40fbe

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `region` | string | No | Amazon marketplace to read, as its domain (e.g. amazon.co.uk); omit it for amazon.com. |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `businessName`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be absent on a se |
| `sellerId` | string | Yes | Amazon seller ID, the value after seller= in a seller page URL (https://www.amazon.com/sp?seller=<id>), e.g. A11V4PRB7HXYNG. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/amazon.seller","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","region":"<string>","requireFields":"<string>","sellerId":"<string>","source":"<string>"}}'
```

### ASOS Product

Fetch an ASOS product by URL from any of its 11 country stores and get title, price, brand, colour, description, images, and per-size stock in one normalized response.

**Price:** \$0.90 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [ASOS Product pricing and uptime](https://getanyapi.com/api/asos/product) - live USD price, lane routing, and measured 30-day uptime. [Every Asos endpoint](https://getanyapi.com/api/asos).

`POST /v1/run/asos.product`

**Cost:** Up to $0.001014 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001014 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/76eb008c-557c-45b3-aa9d-7af3f9052c50

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `sizeGuide`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. Naming a combination that no single source r |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | ASOS product page URL, e.g. https://www.asos.com/pullbear/pullbear-casual-trainers-in-white/prd/211299341, or the short form https://www.asos.com/prd/211299341. The store is read from the URL path (/us/, /au/, /de/ and so on; none means the UK store), and prices come back in that store's currency. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/asos.product","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","source":"<string>","url":"<string>"}}'
```

### Best Buy Product

Fetch a BestBuy.com product by URL and get title, price, brand, model, UPC, rating, description, and images in one normalized response.

**Price:** \$0.85 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Best Buy Product pricing and uptime](https://getanyapi.com/api/bestbuy/product) - live USD price, lane routing, and measured 30-day uptime. [Every Bestbuy endpoint](https://getanyapi.com/api/bestbuy).

`POST /v1/run/bestbuy.product`

**Cost:** Up to $0.000927 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.000927 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/4010487d-3f16-43ef-be3d-8850e207477e

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Best Buy product page URL that carries the numeric Best Buy SKU, either the .../sku/6376564 form the Best Buy Search SKU returns or the older .../6376564.p?skuId=6376564 form. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/bestbuy.product","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### TikTok Ad Transparency Search

Search TikTok's EU Commercial Content Library by keyword or advertiser ID.

**Price:** \$0.80 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [TikTok Ad Transparency Search pricing and uptime](https://getanyapi.com/api/tiktok/ad-transparency-search) - live USD price, lane routing, and measured 30-day uptime. [Every TikTok endpoint](https://getanyapi.com/api/tiktok).

`POST /v1/run/tiktok.ad_transparency_search`

**Cost:** Up to $0.000872 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.000872 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/c3de1d2f-93bd-4d32-8307-aa1951d23a7e

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `advertiserId` | string | No | TikTok Commercial Content Library advertiser ID. Provide advertiserId or query. |
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Search cursor from a previous response's nextCursor. |
| `days` | integer | No | Number of days of Commercial Content Library history to search, from 1 to 365. Defaults to 30. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum number of ads to return, from 1 to 50. Defaults to 20. Billing is flat per request. |
| `offset` | integer | No | Zero-based result offset. Defaults to 0. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | No | Keyword to search in TikTok's EU Commercial Content Library. Provide query or advertiserId. |
| `region` | string | No | Region code for the transparency search. Defaults to DE. |
| `sort` | string | No | Upstream sort expression. Defaults to last_shown_date,desc. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/tiktok.ad_transparency_search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"advertiserId":"<string>","allowFallbacks":"<boolean>","cursor":"<string>","days":"<integer>","ignoreSources":"<string>","limit":"<integer>","offset":"<integer>","preferLatencyUnderMs":"<integer>","query":"<string>","region":"<string>","sort":"<string>","source":"<string>"}}'
```

### Best Buy Search

Search BestBuy.com by keyword with optional sort, price-range, and page filters and get title, price, rating, and brand for each product in one normalized response.

**Price:** \$0.90 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Best Buy Search pricing and uptime](https://getanyapi.com/api/bestbuy/search) - live USD price, lane routing, and measured 30-day uptime. [Every Bestbuy endpoint](https://getanyapi.com/api/bestbuy).

`POST /v1/run/bestbuy.search`

**Cost:** Up to $0.002038 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.002038 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/7f00e778-0525-49e3-bc6c-1cfe091ce6ce

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `maxPrice` | number | No | Optional maximum product price in USD. |
| `minPrice` | number | No | Optional minimum product price in USD. |
| `page` | integer | No | 1-based results page of about 18 to 24 products; Best Buy serves no products past page 100. Each page is billed as one request. Page sizes differ between sources, so deduplicate on sku. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Search keywords, e.g. "airpods" or "65 inch tv". |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `totalResults`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. Naming a combination that no single sourc |
| `sort` | string | No | Result sort order; omit for Best Buy's own relevance order (e.g. price_low sorts by lowest price first). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/bestbuy.search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","maxPrice":"<number>","minPrice":"<number>","page":"<integer>","preferLatencyUnderMs":"<integer>","query":"<string>","requireFields":"<string>","sort":"<string>","source":"<string>"}}'
```

### eBay Product

Fetch one eBay listing by URL and get the full offer record: price, condition, shipping, item location, seller feedback, quantity, watchers, and live auction state (bid count and end time).

**Price:** \$1.20 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [eBay Product pricing and uptime](https://getanyapi.com/api/ebay/product) - live USD price, lane routing, and measured 30-day uptime. [Every Ebay endpoint](https://getanyapi.com/api/ebay).

`POST /v1/run/ebay.product`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/f15386b7-55b6-422f-87a0-8a95d7f1120a

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Full eBay listing URL (e.g. https://www.ebay.com/itm/133576802017). The marketplace is taken from the host, so an ebay.co.uk or ebay.de URL returns that site's listing and currency. Item ids come back on every row of ebay.search and ebay.sold_listings. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/ebay.product","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### Etsy Search

Search Etsy listings by keyword, the same results an Etsy search or /market page shows, with optional sort, price range and page, and get title, price, original price, image, shop, rating and ad flag for each listing in one normalized response.

**Price:** \$0.90 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Etsy Search pricing and uptime](https://getanyapi.com/api/etsy/search) - live USD price, lane routing, and measured 30-day uptime. [Every Etsy endpoint](https://getanyapi.com/api/etsy).

`POST /v1/run/etsy.search`

**Cost:** Up to $0.002038 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.002038 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/9eafea0a-1d01-4f98-9db5-546779445a92

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `maxPrice` | number | No | Optional maximum listing price, in USD. |
| `minPrice` | number | No | Optional minimum listing price, in USD. |
| `page` | integer | No | 1-based results page. Each page is billed as one request. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Search keywords, e.g. "cover letter template". For an Etsy /market page, pass its words: https://www.etsy.com/market/habit_tracker_2027 is the query "habit tracker 2027". |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `rating`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. Naming a combination that no single source retu |
| `sort` | string | No | Result order: relevance (Etsy's own order, the default), newest, price_low, or price_high. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/etsy.search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","maxPrice":"<number>","minPrice":"<number>","page":"<integer>","preferLatencyUnderMs":"<integer>","query":"<string>","requireFields":"<string>","sort":"<string>","source":"<string>"}}'
```

### Etsy Shop

Look up one Etsy shop by name and get its id, location, sales, active listings, rating, reviews count, followers, description, logo and banner in one normalized response.

**Price:** \$0.90 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Etsy Shop pricing and uptime](https://getanyapi.com/api/etsy/shop) - live USD price, lane routing, and measured 30-day uptime. [Every Etsy endpoint](https://getanyapi.com/api/etsy).

`POST /v1/run/etsy.shop`

**Cost:** Up to $0.002038 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.002038 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/4bdaac83-ac6d-4a61-9690-971583eb09ec

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `followers`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. Naming a combination that no single source r |
| `shopName` | string | Yes | Etsy shop name, as in the shop URL (https://www.etsy.com/shop/<name>), e.g. StudioStelleHD. The Etsy Search and Etsy Product SKUs return it as shopName. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/etsy.shop","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","shopName":"<string>","source":"<string>"}}'
```

### X / Twitter Community Search

Search X (Twitter) communities by keyword and get their id, name, topic, and member count with cursor pagination. This is how you find a community URL to pass to twitter.community or twitter.community_tweets.

**Price:** billed per result - \$0.10 per 1,000 requests base + \$0.10 per 1,000 results, capped at \$1.10 per 1,000 requests.

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [X / Twitter Community Search pricing and uptime](https://getanyapi.com/api/x-twitter/search-communities) - live USD price, lane routing, and measured 30-day uptime. [Every X (Twitter) endpoint](https://getanyapi.com/api/x-twitter).

`POST /v1/run/twitter.search_communities`

**Cost:** Up to $0.001199 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001199 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/7577816a-b3cf-461d-8c76-03518b20a122

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Opaque pagination cursor from a previous response's nextCursor. Omit for the first page; pass it to fetch the next page of communities. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | Keyword to match against X (Twitter) community names and topics (e.g. artificial intelligence). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/twitter.search_communities","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","cursor":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","source":"<string>"}}'
```

### Google Trends

Google Trends interest over time for up to 5 search terms compared on one 0-100 scale, where 100 is the peak search interest of any term in the window. Returns one series per term, in the order you sent them, with a value for every time bucket. Choose the country or region with geo (worldwide when omitted) and the window with timeframe (the past 12 months when omitted); both are echoed in the response. Interest over time only, not related queries or regions.

**Price:** \$2.00 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Google Trends pricing and uptime](https://getanyapi.com/api/google/trends) - live USD price, lane routing, and measured 30-day uptime. [Every Google endpoint](https://getanyapi.com/api/google).

`POST /v1/run/google.trends`

**Cost:** Up to $0.01744 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.01744 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/468851bc-4dd3-44f9-856d-dd6db2ca8d15

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `geo` | string | No | Where the searches came from: an uppercase ISO country code (US, GB, DE) or a country subdivision (US-CA, GB-ENG). Omit it, or send worldwide, for worldwide interest. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `keywords` | string | Yes | Search terms to compare, 1 to 5, each 2 to 100 characters and without commas (e.g. ["coffee", "tea"]). Values are relative across the whole set, so the same term scores differently next to different terms. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `timeframe` | string | No | The window to chart, ending now: 1h, 4h, 1d or 7d (hours and days), 1m or 3m (months), 12m, 5y, or all (back to January 2004). Buckets grow with the window: minutes up to 1d, hours for 7d, days for 1m and 3m, weeks for 12m and 5y, months for all. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/google.trends","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","geo":"<string>","ignoreSources":"<string>","keywords":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","timeframe":"<string>"}}'
```

### Reddit Subreddit Posts

Fetch posts from a subreddit listing (hot, new, or top).

**Price:** \$0.38 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 3 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Reddit Subreddit Posts pricing and uptime](https://getanyapi.com/api/reddit/subreddit-posts) - live USD price, lane routing, and measured 30-day uptime. [Every Reddit endpoint](https://getanyapi.com/api/reddit).

`POST /v1/run/reddit.subreddit_posts`

**Cost:** Up to $0.001308 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.001308 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/02f34da6-d5c0-4820-91b2-1222b893b856

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `after` | string | No | Legacy pagination alias. Prefer `cursor`; omit both fields for the first page. |
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `cursor` | string | No | Opaque pagination cursor from a previous response's `nextCursor`; omit for the first page. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Page size to ask for (up to 100). Some sources honor it; others always return their whole page of about 25 posts. A page is never trimmed after the call, so pass nextCursor back as cursor to continue exactly where this response ended. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `isArchived` or `selftext`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be ab |
| `sort` | string | No | Listing sort order. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `subreddit` | string | Yes | Subreddit name without the leading r/ (e.g. "golang"). |
| `timeframe` | string | No | Time window, applied when sort is "top" (e.g. "year" for the year's top posts). Ignored for hot/new. Omit to default to the current day for top. |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/reddit.subreddit_posts","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"after":"<string>","allowFallbacks":"<boolean>","cursor":"<string>","ignoreSources":"<string>","limit":"<integer>","preferLatencyUnderMs":"<integer>","requireFields":"<string>","sort":"<string>","source":"<string>","subreddit":"<string>","timeframe":"<string>"}}'
```

### Reddit Trending Posts

Get currently trending Reddit posts across all subreddits with stable cursor pagination.

**Price:** \$0.30 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Reddit Trending Posts pricing and uptime](https://getanyapi.com/api/reddit/trending-posts) - live USD price, lane routing, and measured 30-day uptime. [Every Reddit endpoint](https://getanyapi.com/api/reddit).

`POST /v1/run/reddit.trending_posts`

**Cost:** Up to $0.000327 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.000327 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/669217e9-cb6e-447d-b976-0ead637e30a0

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `after` | string | No | Pagination cursor from a previous response's nextCursor. Omit for the first page. |
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum number of trending posts to return (1-100, default 25). |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/reddit.trending_posts","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"after":"<string>","allowFallbacks":"<boolean>","ignoreSources":"<string>","limit":"<integer>","preferLatencyUnderMs":"<integer>","source":"<string>"}}'
```

### Redfin Property

Fetch full details for a single Redfin home by its listing URL (price, beds, baths, square feet, address, listing agent, description and photos) as normalized JSON.

**Price:** \$0.80 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Redfin Property pricing and uptime](https://getanyapi.com/api/redfin/property) - live USD price, lane routing, and measured 30-day uptime. [Every Redfin endpoint](https://getanyapi.com/api/redfin).

`POST /v1/run/redfin.property`

**Cost:** Up to $0.000872 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.000872 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/587f6cb7-6f91-4c1c-a407-1116505d449f

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Redfin home details URL (e.g. https://www.redfin.com/TX/Austin/1819-Village-Oak-Ct-78704/home/30981993). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/redfin.property","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

### Target Reviews

Pull a page of 10 customer reviews for any Target.com product by URL, newest first or by helpfulness or rating: rating, title, text, date, reviewer, and verified-purchase badge.

**Price:** \$0.85 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Target Reviews pricing and uptime](https://getanyapi.com/api/target/reviews) - live USD price, lane routing, and measured 30-day uptime. [Every Target endpoint](https://getanyapi.com/api/target).

`POST /v1/run/target.reviews`

**Cost:** Up to $0.000927 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.000927 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/a6d9cae1-cb09-4838-a4fb-5fdeccce2f99

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `page` | integer | No | 1-based page of 10 reviews. Each page is billed as one request; keep url and sort the same while walking pages. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `sort` | string | No | Review order: recent (newest first, the default), helpful, rating_high, or rating_low (e.g. helpful). |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Target product page URL; the TCIN after /A- identifies the product (e.g. https://www.target.com/p/-/A-91863920). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/target.reviews","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","page":"<integer>","preferLatencyUnderMs":"<integer>","sort":"<string>","source":"<string>","url":"<string>"}}'
```

### Bing Search

Run a Bing web search and get the ranked organic results (title, URL, snippet, position, display URL, domain) plus Bing's related searches as clean JSON. Returns up to 10 results per call; pick the country Bing searches from.

**Price:** \$0.85 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Bing Search pricing and uptime](https://getanyapi.com/api/bing/search) - live USD price, lane routing, and measured 30-day uptime. [Every Bing endpoint](https://getanyapi.com/api/bing).

`POST /v1/run/bing.search`

**Cost:** Up to $0.000927 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.000927 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/cfa3678e-e733-495e-acc3-85e6ae07f510

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `country` | string | No | ISO-3166 alpha-2 country Bing searches from, e.g. US, GB, DE. Bing ranks and localizes results for that country and its main language. Common countries are served by every source; a country only some sources cover is served by those, and one no source covers is refused with no charge. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `limit` | integer | No | Maximum number of organic results to return (1-10, default 10). Bing serves about 10 organic results per page, and some queries carry fewer. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | The Bing search query. |
| `requireFields` | string | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Name the output fields this request must be able to return, for example `siteName` or `publishedUtc`, and it is served only by a source that returns every one of them. Fields you do not name are still returned whenever the serving source has them. This can raise your price: when the cheapest source cannot return a named field, a dearer source serves, and you are quoted and charged its price. A named field can still be |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/bing.search","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","country":"<string>","ignoreSources":"<string>","limit":"<integer>","preferLatencyUnderMs":"<integer>","query":"<string>","requireFields":"<string>","source":"<string>"}}'
```

### Google Search Top 100

Run a Google web search and get up to 100 ranked organic results in one call, with true absolute positions rather than per-page numbering. One charge per call whatever the depth, which normally makes it cheaper than paging google.search past roughly 20 results; when the backup source has to answer, the call costs more, up to $0.024. It reads ten pages of Google to build the list, so a call can take up to about five minutes - use google.search when you want the first page back in a second.

**Price:** \$24.00 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** one lane serves this API today, so a failed attempt has nowhere to fail over to. Payment outcome follows the selected rail's settlement policy.

**Catalog:** [Google Search Top 100 pricing and uptime](https://getanyapi.com/api/google/search-100) - live USD price, lane routing, and measured 30-day uptime. [Every Google endpoint](https://getanyapi.com/api/google).

`POST /v1/run/google.search_100`

**Cost:** Up to $0.02616 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.02616 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/d8ca5f0d-254a-4ba1-a980-bb30ee4f1c9a

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `autocorrect` | boolean | No | Toggle Google spelling autocorrect (default true). Set false to search the exact query without correction. |
| `gl` | string | No | Two-letter country code for result localization (e.g. us, gb, de). |
| `hl` | string | No | Two-letter interface and results language code (e.g. en, es, de). |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `query` | string | Yes | The Google search query. |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `timeframe` | string | No | Restrict results to a recent time window: 1h, 1d, 7d, 1y, or all. Default all (no time restriction). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/google.search_100","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","autocorrect":"<boolean>","gl":"<string>","hl":"<string>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","query":"<string>","source":"<string>","timeframe":"<string>"}}'
```

### Zillow Agent

Fetch one Zillow real estate agent's profile by URL: name, phone, email, brokerage, rating, review count, sales, and service areas.

**Price:** \$0.80 per 1,000 requests (flat per request - same cost regardless of results returned).

**Routing:** 2 independent lanes are available in execution order. A failed attempt uses the next lane only when the request's payment authorizes that lane's price; the normalized schema stays the same.

**Catalog:** [Zillow Agent pricing and uptime](https://getanyapi.com/api/zillow/agent) - live USD price, lane routing, and measured 30-day uptime. [Every Zillow endpoint](https://getanyapi.com/api/zillow).

`POST /v1/run/zillow.agent`

**Cost:** Up to $0.009472 per call. Response-based: the price is worked out from the usage reported in the response, never more than $0.009472 per call. You aren't charged for failed calls. A wallet payment for a failed call is refunded.
- If you pay with a wallet (x402, MPP or Nanopayments), you pay this request's price before the call, not the final price from the response

Use `"dryRun": true` in the Run API request to see a request's price before calling.

**Page:** https://www.orthogonal.com/api/anyapi/1213b243-01ce-467c-a3ec-9bbeccdfc91e

**Docs:** https://getanyapi.com/docs

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `allowFallbacks` | boolean | No | Optional, default true. When false, only the sources listed in `source` may serve; the request is refused with no charge if none of them can. When true, the listed sources are tried first and any other source may serve after them, at the normal price. |
| `ignoreSources` | string | No | Optional. Source ids to skip for this request, taken from this endpoint's `lanes[].source.id`. The cheapest remaining source serves and the price is that of the dearest remaining source. An id that does not serve this endpoint, or that is also in `source`, is rejected as invalid input with no charge; skipping every source is rejected the same way. |
| `preferLatencyUnderMs` | integer | No | Optional; omit it and routing is unchanged, with the cheapest source serving. Prefer sources whose typical response time (median over the trailing 30 days, as published on this endpoint's lane health) is under this many milliseconds; among those, the cheapest serves. This can raise your price: when the cheapest source misses the target, a faster and dearer one serves, and you are quoted and charged its price. If no source is that fast the request is still served, by whichever source offers the b |
| `source` | string | No | Optional. Source ids to prefer, in order, taken from this endpoint's `lanes[].source.id` in /catalog or /apis. Omit it and the cheapest source serves, with automatic failover. Listed sources are tried first in the order given, then the others, unless `allowFallbacks` is false. A single source with `allowFallbacks` false is served only by that source at its price, quoted and charged exactly, with no failover. The price is that of the dearest source that may serve. An id that does not serve this e |
| `url` | string | Yes | Zillow agent profile URL (e.g. https://www.zillow.com/profile/gregorycarlsonATX/). |
| `fields` | string | No | Optional. Comma-separated keys (dotted paths like `author.name` descend into nested objects) to keep on each result item: each row of the API's result list, or the `data` object itself for an API that returns one record. Keys are matched relative to that item, not against the top-level response envelope, so use `jq` to reshape the whole envelope. Shrinks the response without changing cost. |
| `max_items` | integer | No | Optional. Cap the number of result rows returned; a `_truncated` note reports how many were withheld so you can page via the API's own `limit`. An API that returns one record is not trimmed. Does not change cost. |
| `summary` | boolean | No | Optional. Return only a structural outline (top-level keys, item counts, and per-field byte sizes) instead of the full data. Does not change cost. |
| `jq` | string | No | Optional. A jq expression applied to the result envelope; its output replaces `output` (multiple outputs collect into an array). Reshape freely, e.g. `jq=.data \| {title, description, md: .markdown[:3500]}`. Runs sandboxed with a 250ms / 2MB budget; on failure the full result is returned with a `jqError`. Does not change cost. |
| `max_cost_usd` | string | No | Optional. The most you are willing to pay for this one request, in US dollars (for example 0.05). Any route that would charge more than this is not used, so a request only ever runs on something you can afford. If nothing is available at or below your amount, the request is refused before it runs, nothing is charged, and the message tells you the cheapest price per request so you can raise it. Leave it out to accept the normal price. |

```bash
curl -X POST 'https://api.orthogonal.com/v1/run' \
  -H 'Authorization: Bearer $ORTHOGONAL_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"api":"anyapi","path":"/v1/run/zillow.agent","query":{"fields":"<string>","max_items":"<integer>","summary":"<boolean>","jq":"<string>","max_cost_usd":"<string>"},"body":{"allowFallbacks":"<boolean>","ignoreSources":"<string>","preferLatencyUnderMs":"<integer>","source":"<string>","url":"<string>"}}'
```

---

Full details and an interactive quickstart: https://www.orthogonal.com/publisher/anyapi
