> ## Documentation Index
> Fetch the complete documentation index at: https://getanyapi.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# 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.



## OpenAPI

````yaml /openapi.json get /catalog/search
openapi: 3.1.0
info:
  contact:
    email: support@getanyapi.com
  description: >-
    Any API, one wallet, USD, no subscriptions. Each API is a single discovered
    operation: send the normalized input, get a normalized result. Prices and
    payment outcomes are reported in USD; each operation documents the
    settlement policy for its enabled payment rails.
  title: AnyAPI
  version: 1.0.0
  x-guidance: >-
    Use each operation's published method and path with its normalized JSON
    input (see the operation requestBody). Before setting a client or tool
    timeout, GET /v1/apis/{sku} and inspect its trailing-30-day latency
    p50/p95/p99 and sample; p99 is an observation, not a maximum. To pay: send
    your AnyAPI key (Authorization: Bearer, billed from your USD wallet). For
    operations that advertise an inline rail, pay per call inline with x402 -
    call with no key, receive HTTP 402 with a PAYMENT-REQUIRED header, then
    retry with the PAYMENT-SIGNATURE header (base, no account needed); or pay
    per call inline with MPP (Machine Payments Protocol) - call with no key,
    receive HTTP 402 with a WWW-Authenticate: Payment challenge, then retry with
    the Authorization: Payment header (tempo, no account needed). x402 settles
    after execution; execution failure is reported as released; mpp settles
    before execution; execution failure is reported as charged_undelivered.
servers:
  - url: https://api.getanyapi.com
security:
  - bearerAuth: []
  - apiKeyAuth: []
tags:
  - name: ahrefs
    x-group: Ahrefs
  - name: airbnb
    x-group: Airbnb
  - name: alibaba
    x-group: Alibaba
  - name: amazon
    x-group: Amazon
  - name: apollo
    x-group: Apollo
  - name: appstore
    x-group: Appstore
  - name: bluesky
    x-group: Bluesky
  - name: booking
    x-group: Booking
  - name: capterra
    x-group: Capterra
  - name: chatgpt
    x-group: Chatgpt
  - name: coinmarketcap
    x-group: Coinmarketcap
  - name: company
    x-group: Company
  - name: company-enrichment
    x-group: Company_enrichment
  - name: company-search
    x-group: Company_search
  - name: congress
    x-group: Congress
  - name: dexscreener
    x-group: Dexscreener
  - name: douyin
    x-group: Douyin
  - name: ebay
    x-group: Ebay
  - name: email
    x-group: Email
  - name: email-finding
    x-group: Email_finding
  - name: email-verification
    x-group: Email_verification
  - name: facebook
    x-group: Facebook
  - name: fiverr
    x-group: Fiverr
  - name: g2
    x-group: G2
  - name: gemini
    x-group: Gemini
  - name: github
    x-group: Github
  - name: glassdoor
    x-group: Glassdoor
  - name: google
    x-group: Google
  - name: google-ads
    x-group: Google Ads
  - name: google-finance
    x-group: Google Finance
  - name: google-shopping
    x-group: Google Shopping
  - name: hackernews
    x-group: Hackernews
  - name: indeed
    x-group: Indeed
  - name: instagram
    x-group: Instagram
  - name: job-search
    x-group: Job_search
  - name: linkedin
    x-group: Linkedin
  - name: maps
    x-group: Maps
  - name: mobile-phone
    x-group: Mobile_phone
  - name: naver
    x-group: Naver
  - name: pandaexpress
    x-group: Pandaexpress
  - name: people-search
    x-group: People_search
  - name: perplexity
    x-group: Perplexity
  - name: person
    x-group: Person
  - name: person-enrichment
    x-group: Person_enrichment
  - name: pinterest
    x-group: Pinterest
  - name: playstore
    x-group: Playstore
  - name: polymarket
    x-group: Polymarket
  - name: realtor
    x-group: Realtor
  - name: reddit
    x-group: Reddit
  - name: redfin
    x-group: Redfin
  - name: rednote
    x-group: Rednote
  - name: sec
    x-group: Sec
  - name: semrush
    x-group: Semrush
  - name: seo
    x-group: Seo
  - name: snapchat
    x-group: Snapchat
  - name: social
    x-group: Social
  - name: spotify
    x-group: Spotify
  - name: substack
    x-group: Substack
  - name: technographics
    x-group: Technographics
  - name: threads
    x-group: Threads
  - name: tiktok
    x-group: TikTok
  - name: tiktok-shop
    x-group: TikTok Shop
  - name: tripadvisor
    x-group: Tripadvisor
  - name: trustpilot
    x-group: Trustpilot
  - name: truthsocial
    x-group: Truthsocial
  - name: twitter
    x-group: X (Twitter)
  - name: upwork
    x-group: Upwork
  - name: walmart
    x-group: Walmart
  - name: web
    x-group: Web
  - name: weibo
    x-group: Weibo
  - name: yahoo-finance
    x-group: Yahoo Finance
  - name: yelp
    x-group: Yelp
  - name: youtube
    x-group: YouTube
  - name: zhihu
    x-group: Zhihu
  - name: zillow
    x-group: Zillow
paths:
  /catalog/search:
    get:
      summary: Search the API catalog
      description: >-
        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.
      operationId: searchCatalog
      parameters:
        - description: >-
            What you need, in your own words. Long queries are truncated before
            ranking.
          in: query
          name: q
          required: false
          schema:
            type: string
        - description: Restrict the response to one category, using an entry's `category`.
          in: query
          name: category
          required: false
          schema:
            type: string
        - description: Restrict results to one platform, using a result's `platformId`.
          in: query
          name: platform
          required: false
          schema:
            type: string
        - description: >-
            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.
          in: query
          name: limit
          required: false
          schema:
            minimum: 1
            type: integer
      responses:
        '200':
          content:
            application/json:
              schema:
                properties:
                  ranking:
                    description: Which ranker served this response.
                    enum:
                      - keyword
                      - semantic
                    type: string
                  results:
                    items:
                      $ref: '#/components/schemas/CatalogSearchResult'
                    type: array
                  total:
                    description: Matches found before `limit` was applied.
                    type: integer
                required:
                  - results
                  - total
                  - ranking
                type: object
          description: Ranked matches.
        '400':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
          description: The request named neither a query nor a scope.
      security: []
components:
  schemas:
    CatalogSearchResult:
      properties:
        category:
          description: The API's category, accepted back as the `category` scope.
          type: string
        description:
          description: One-line summary of what this API returns.
          type: string
        excludesCallerDelay:
          description: >-
            Present when this API accepts a caller-requested wait that the
            published latency excludes.
          type: boolean
        execution:
          allOf:
            - $ref: '#/components/schemas/DiscoveryExecution'
          description: The runtime protocol a run of this API follows.
        failover:
          description: True when more than one source can serve this API.
          type: boolean
        highlightFields:
          description: >-
            Output fields of this API that matched the query, with each field's
            own schema description as `why`. Computed for the top few results
            only, so an absent array means no highlights were produced rather
            than no matching field.
          items:
            $ref: '#/components/schemas/DiscoveryHighlightField'
          type: array
        method:
          description: HTTP method for this API's concrete operation.
          type: string
        name:
          description: Display name.
          type: string
        path:
          description: Concrete gateway path for this API.
          type: string
        platformId:
          description: The API's platform, accepted back as the `platform` scope.
          type: string
        pricing:
          allOf:
            - $ref: '#/components/schemas/DiscoveryPricing'
          description: Static USD pricing for this API.
        provider:
          const: AnyAPI
          description: Always "AnyAPI".
          type: string
        relevance:
          description: How well this API matched, relative to the others in this response.
          type: number
        slug:
          description: The API's slug. Feed it to GET /v1/apis/{sku} for the input schema.
          type: string
        tryMaxItems:
          description: The most items the free try returns, when this API is try-eligible.
          type: integer
      required:
        - slug
        - category
        - name
        - description
        - method
        - path
        - provider
        - execution
        - pricing
        - failover
        - platformId
        - relevance
      type: object
    Error:
      properties:
        code:
          description: Stable machine-readable error code when the endpoint defines one.
          type: string
        error:
          description: Customer-safe error message.
          type: string
        payment:
          $ref: '#/components/schemas/Payment'
        requestId:
          description: >-
            This run's AnyAPI request id, the same value as the
            X-Anyapi-Request-Id response header. Quote it to support. Absent on
            endpoints that do not execute a run.
          format: uuid
          type: string
      required:
        - error
      type: object
    DiscoveryExecution:
      properties:
        mode:
          description: >-
            sync answers on the run request; durable accepts the run as a
            Request you poll at GET /v1/requests/{id}.
          enum:
            - sync
            - durable
          type: string
      required:
        - mode
      type: object
    DiscoveryHighlightField:
      properties:
        path:
          description: JSON path of the output field inside this API's outputSchema.
          type: string
        type:
          description: JSON type of that field.
          type: string
        why:
          description: >-
            The field's own schema description. Absent when the schema gives
            none.
          type: string
      required:
        - path
        - type
      type: object
    DiscoveryPricing:
      properties:
        failoverMaxPer1kUsd:
          description: failoverMaxUsd in the per-1,000-request denomination.
          type: number
        failoverMaxUsd:
          description: >-
            The greatest customer-price maximum across those same sources, in
            USD.
          type: number
        from:
          allOf:
            - $ref: '#/components/schemas/DiscoveryOffer'
          description: >-
            The complete offer for the first source that will be tried, where
            sources are ordered by the customer charge, cheapest first.
      required:
        - from
        - failoverMaxUsd
        - failoverMaxPer1kUsd
      type: object
    Payment:
      properties:
        costUsd:
          description: Known USD payment amount for this request.
          minimum: 0
          type: number
        rail:
          minLength: 1
          type: string
        settlementState:
          enum:
            - charged_undelivered
            - indeterminate
          type: string
      required:
        - rail
        - settlementState
        - costUsd
      type: object
    DiscoveryOffer:
      properties:
        baseUsd:
          description: >-
            Linear offers only: USD charged for the call before per-unit
            billing.
          type: number
        maxPer1kUsd:
          description: >-
            The same maximum in the per-1,000-request denomination AnyAPI quotes
            customers in. It is published rather than left to the client, so
            display this figure instead of scaling a price yourself.
          type: number
        maxUsd:
          description: The most one request on this offer can be billed, in USD.
          type: number
        model:
          description: >-
            Pricing model. A flat offer is one price per request; a linear offer
            also carries baseUsd and perUnitUsd.
          enum:
            - flat
            - linear
          type: string
        perUnitUsd:
          description: >-
            Linear offers only: USD charged for each billable unit inside the
            call.
          type: number
        unit:
          description: The billable unit. A flat offer always publishes "request".
          type: string
      required:
        - model
        - unit
        - maxUsd
        - maxPer1kUsd
      type: object
  securitySchemes:
    bearerAuth:
      description: Your AnyAPI key as a Bearer token.
      scheme: bearer
      type: http
      x-default: YOUR_ANYAPI_KEY
    apiKeyAuth:
      description: Your AnyAPI key.
      in: header
      name: X-API-Key
      type: apiKey
      x-default: YOUR_ANYAPI_KEY

````