DEVELOPER API

MyAnagramSolver API
Word Game API — Planning Documentation

Documentation for the planned MyAnagramSolver word game API. Current architecture is browser-first — all existing tools run client-side with no API key required. This page documents the planned server-side API for integration by developers.

Browser-First Architecture API In Planning 74,872-Word Database Free Tier Planned

Current Architecture — Browser-First, No API Required

All current tools on MyAnagramSolver operate entirely in the browser. The 74,872-word database is loaded as a JavaScript file and all anagram solving, prefix matching, suffix matching, pattern finding, and scoring runs client-side. No API key is required to use any existing tool.

This means: no server round-trips for tool operations, no rate limits for browser users, and no data sent to any server when you use a tool. The browser-first design is both faster for users and simpler architecturally than a server-side API.

The API documented below is a planned addition that will allow developers to integrate word game functionality into their own applications — where loading the full JavaScript word database client-side is not appropriate.

Planned API Endpoints

GET
/api/v1/solve — anagram solving
Parameters: letters (required, max 20 chars), mode (subset|exact, default subset), min_length (integer), max_length (integer). Returns: array of matching words with length and Scrabble base score. Example: /api/v1/solve?letters=LISTEN&mode=exact returns ENLIST, INLETS, LISTEN, SILENT, TINSEL.
GET
/api/v1/prefix — startsWith() matching
Parameters: prefix (required, max 10 chars), min_length (integer), max_length (integer), sort (alpha|score|length). Returns: array of words starting with the prefix, count, and scores. Example: /api/v1/prefix?prefix=INTER returns all 258 database words beginning with INTER.
GET
/api/v1/suffix — endsWith() matching
Parameters: suffix (required, max 10 chars), min_length (integer), max_length (integer), sort (alpha|score|length). Returns: array of words ending with the suffix, count, and scores. Example: /api/v1/suffix?suffix=TION returns all 1,259 database words ending in TION.
GET
/api/v1/pattern — positional matching
Parameters: pattern (required, max 15 chars, ? and _ as wildcards). Returns: matching words and count. Example: /api/v1/pattern?pattern=C??T returns all 4-letter words starting with C and ending with T. Pattern length determines word length.
GET
/api/v1/score — Scrabble scoring
Parameters: word (required, max 20 chars), blanks (optional, letters played as blanks scoring 0). Returns: total base score, letter-by-letter breakdown. Example: /api/v1/score?word=PIZZAZZ returns total 45 with per-letter values.
GET
/api/v1/validate — word existence check
Parameters: word (required). Returns: valid (boolean), length, score. Example: /api/v1/validate?word=QUIZZICALLY returns valid: true, length: 11, score: 43. Useful for validating game plays without retrieving full result sets.

Rate Limits and Authentication

Free tier (unauthenticated): 100 requests per hour per IP address. Burst allowance: 10 requests per 10 seconds. No API key required. Responses include X-RateLimit-Remaining and X-RateLimit-Reset headers.

Authenticated tier: 1,000 requests per hour per API key. API keys are issued via the developer registration page (not yet live). Authentication uses Bearer token scheme in the Authorization header: Authorization: Bearer your-api-key.

Caching: identical queries are cached for 1 hour (Cache-Control: public, max-age=3600). All endpoints are deterministic — the same query always produces the same result for a given database version. Responses include the database fingerprint (916f47949b41) in the X-DB-Fingerprint header so integrators can detect database updates.

Security Model

HTTPS only: all API endpoints require HTTPS. HTTP requests receive a 301 redirect to HTTPS.

Input validation: letter inputs are validated for maximum length (30 characters) and character set (A–Z plus ? and _ for pattern endpoints). Invalid characters return a 400 error with a descriptive message.

No database export: the API returns results matching query parameters — not raw word lists. There is no bulk export endpoint. The full word database is not available via the API, only individual query results.

Privacy: query content beyond hashed metrics is not stored in server logs. No personally identifiable information is associated with API usage. Free-tier usage is tracked by hashed IP for rate limiting only.

CORS: API endpoints are accessible cross-origin for GET requests. Responses include appropriate Access-Control-Allow-Origin headers. POST, PUT, and DELETE methods are not supported.

Licensing and Terms

Free tier usage is licensed for personal, educational, and non-commercial applications. Commercial applications — including apps distributed to users, services monetised by advertising, and tools integrated into commercial products — require an authenticated API key and agreement to the commercial terms.

The word database used by the API includes words from the TWL (Tournament Word List) and Collins Scrabble Words. Applications distributing word lists derived from API results must independently comply with those source licences. MyAnagramSolver provides tool functionality, not a licence to distribute the underlying word lists.

Current Status and Developer Notes

The MyAnagramSolver API is currently in planning stage. No server endpoints are live. This page documents the intended architecture for developers who want to integrate word game functionality into their applications. All current tool functionality is available without an API key through the browser-based tools on this site.

The decision to build browser-first was deliberate. Loading the complete 74,872-word database client-side eliminates all server-side latency for word processing. Every tool returns results in under 100 milliseconds for any query. A server API introduces round-trip latency for every request — a measurable round-trip latency depending on geography — which would make interactive tools feel slower than the browser-first alternative. For the primary use case (browser-based word game assistance), the JavaScript approach is strictly superior.

The planned API targets a different use case: developers building their own applications who cannot or do not want to load the full word database JavaScript file in their client. Mobile apps, server-side rendering pipelines, integrations with other tools, and applications with strict bundle size requirements all benefit from a server API that handles the database lookup remotely and returns only the relevant results. For these use cases, the small result payload returned by the API is more appropriate than loading the full database.

If you are a developer interested in using the API when it becomes available, the documentation on this page describes the intended interface. The endpoint structure, parameter names, and response format described here represent the current design and are subject to change before the API goes live. The browser-based tools on this site implement the same algorithms that the API will expose — they are a working reference implementation of the intended API behaviour.

For rate limiting purposes: the planned free tier at 100 requests per hour is generous for most hobby and educational use cases. A developer building an interactive crossword assistant that makes one API call per user query would need approximately 100 active simultaneous users each solving one crossword per hour to reach the free tier limit. The authenticated tier at 1,000 requests per hour accommodates small to medium commercial applications.