Anagram Solver API

The anagram solver API takes a string of alphabetical characters and returns all valid words in our dictionary that can be made from those letters (i.e., all valid anagrams).

On this page

• Consuming the API
• Endpoint Open API Specification
• Example Request
• Request Parameters
• Example Response

Consuming the API

• Navigate to the Word Checker Rapid API page.
• You will need to setup a Rapid API account and application to use our APIs. We offer a free subscription package on Rapid API, however, you may need to switch to a paid subscription if your application traffic grows.
• Click on the /v1/tools/anagram-solver/{letters} section.

Endpoint Open API Specification

openapi: 3.0.4

info:
  title: Word Checker Service
  description: API of word tools such as anagram solvers, random word generators, and more.
  version: 1.0.0

paths:
  /v1/tools/anagram-solver/{letters}:
    get:
      summary: Anagram Solver
      parameters:
        - name: letters
          in: path
          description: The letters to find an anagrams of
          required: true
          schema:
            type: string
      responses:
        "200":
          $ref: "#/components/responses/SortedWordListResponse"
        "400":
          $ref: "#/components/responses/ErrorResponse"
        "429":
          $ref: "#/components/responses/TooManyRequests"

components:
  responses:
    ErrorResponse:
      description: A generic error responses with error code and hint
      content:
        application/json:
          schema:
            type: object
            properties:
              error:
                description: The error code
                type: string
                example: ERROR_CODE
              error_hint:
                description: A hint to resolve the error
                type: string
                example: Error hint
            required:
              - error
              - error_hint
    TooManyRequests:
      description: Too Many Requests
      content:
        application/json:
          schema:
            type: object
            properties:
              error:
                description: The error code
                type: string
                example: TOO_MANY_REQUESTS
              error_hint:
                description: A hint to resolve the error
                type: string
                example: You're making requests a bit too quickly. Please wait a moment and try again.
            required:
              - error
              - error_hint
    SortedWordListResponse:
      description: A JSON object containing a count of found words and found words as an object with the word length as a key
      content:
        application/json:
          schema:
            type: object
            properties:
              results:
                description: A count of the total found words
                type: integer
                example: 1
              found_words:
                description: A object containing all found words, with the word length as a key
                $ref: "#/components/schemas/SortedWordList"
            required:
              - results
              - found_words
  schemas:
    SortedWordList:
      description: An object with the words length as a key
      type: object
      example: "2"
      additionalProperties:
        description: An array of words of a specific length
        type: array
        items:
          type: string
        example: ["HI", "HA"]

Example Request

curl --request GET \
	--url https://word-checker-api.p.rapidapi.com/v1/tools/anagram-solver/$LETTERS \
	--header 'x-rapidapi-host: word-checker-api.p.rapidapi.com' \
	--header 'x-rapidapi-key: $YOUR_RAPID_API_KEY'

Request Parameters

Path Parameters

• LETTERS: The letters to find an anagrams of. Must be a minimum of 2 characters and maximum of 15 characters.

Headers

• YOUR_RAPID_API_KEY: You’re Rapid API key to authenticate the request. See Rapid APIs docs.

Example Response

A successful response will contain a JSON object with a count of the anagrams found and a found_words object. The found_words object keys are the length of the word(s) and the value is an array containing the matching anagrams of that length.

{
  "results": 6,
  "found_words": {
    "2": ["HE", "EH", "YE"],
    "3": ["HEY", "HYE", "YEH"]
  }
}

If a response is unsuccessful, a standard error response will be returned. For example, the below represents an INVALID_LENGTH error.

{
  "error": "INVALID_LENGTH",
  "error_hint": "A maximum of 15 letters can be submitted."
}

The error_hint is meant for the application/server and may not always make sense to display to the end user.