API marketplace

Compute Elo ratings — the rating system behind chess, esports, games and competitive leaderboards. The expected endpoint takes two players' ratings and returns each side's win probability using the classic logistic formula 1 / (1 + 10^((Rb − Ra) / 400)), names the favourite and reports the rating gap. The match endpoint applies a result — a win, loss or draw for player A — and returns both players' updated ratings, the exact points each one gained or lost, and the expected scores, using a configurable K-factor (32 by default; lower for established players, higher for newcomers, so ratings settle or move quickly as you choose). An upset is rewarded with a bigger swing and a draw shifts points toward the underdog, exactly as Elo intends. Everything is computed locally and deterministically, so it is instant and private — no players or leaderboard are stored. Ideal for games and esports matchmaking, chess and board-game apps, tournament and ladder systems, ranking and reputation features, and A/B-style skill comparisons. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This computes ratings from inputs you provide; it does not store a leaderboard or look up a player's rating.

Uptime

100.0%

Latency

82ms

Subs

3,641

Calculate a weighted grade-point average (GPA). The calc endpoint takes a list of courses — each with a grade and the credit hours it is worth — and returns the credit-weighted GPA, the totals, and a per-course breakdown of quality points so you can see exactly how the average was formed. Grades may be US letter grades (A, A-, B+, … F) on the standard 4.0 scale, or 4.3 with the us_plus scale that gives A+ extra weight; percentages from 0 to 100 mapped to letters and points with the usual cutoffs; raw grade points given directly as numbers; or your own custom letter-to-point mapping for any institution's scheme. Courses can be passed as a JSON array or a compact string like "A:3,B+:4,C:2", and credits default to 1 for an unweighted average. The scales endpoint lists the built-in grade scales and their point values. Everything is computed locally and deterministically, so it is instant and private — no student data is stored. Ideal for student planners and dashboards, university and school portals, LMS and ed-tech apps, scholarship and admissions tools, and academic what-if calculators. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This computes GPA; for general statistics use a statistics API.

Uptime

100.0%

Latency

73ms

Subs

3,627

Map numbers between ranges. The scale endpoint linearly maps a value from an input range [in_min, in_max] onto an output range [out_min, out_max] — the classic map() you reach for with sensor readings, sliders and knobs, gauges and progress bars, and data-visualisation axes. It also returns the 0–1 position t, so with the default 0–1 output range it normalizes a value, and with a 0–1 input range it interpolates (lerp); output ranges may be reversed (out_min greater than out_max) to invert direction, and an optional clamp keeps the result inside the output range instead of extrapolating. The clamp endpoint constrains a value to a minimum and maximum and can additionally snap it to the nearest step. Everything is exact local maths, instant and deterministic. Ideal for IoT and embedded (Arduino-style map), audio and DSP, graphics and game development, dashboards and charts, and UI controls. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This maps scalar values — for interpolating vectors use a vector API and for animation easing curves use an easing API.

Uptime

100.0%

Latency

83ms

Subs

4,312

Work with subtitle and caption files — parse, convert and re-sync, entirely locally. The parse endpoint reads SubRip (.srt) or WebVTT (.vtt) text into clean, structured cues — index, start, end (as both HH:MM:SS,mmm timecodes and milliseconds), duration and the cue text (multi-line preserved) — auto-detecting which format you sent. The convert endpoint converts between SRT and WebVTT, getting the details right: the timestamp separator (comma for SRT, dot for WebVTT), adding or removing the WEBVTT header, and renumbering cues. The shift endpoint moves every timestamp by an offset in milliseconds, positive or negative, to fix a track that runs early or late, clamping at zero so nothing goes negative. Everything is computed locally and deterministically, so it is instant and private — your media files never leave the request. Ideal for video and streaming pipelines, caption editors and players, localization and translation workflows, accessibility, and fixing out-of-sync subtitles. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 4 endpoints. This handles subtitle files; for SMPTE video timecode (HH:MM:SS:FF) use a timecode API.

Uptime

100.0%

Latency

76ms

Subs

4,884

Exact fraction maths with arbitrary-precision integers — no floating-point rounding. The simplify endpoint reduces any fraction to its lowest terms and returns the decimal value, the mixed-number form (10/4 → 2 1/2) and whether it is a whole number. The calc endpoint adds, subtracts, multiplies or divides two values — given as fractions (1/2), whole numbers, mixed numbers (1 1/2) or decimals (0.5) — and returns the simplified result. The fromdecimal endpoint turns a decimal into a fraction: exactly for terminating decimals, and precisely for repeating decimals written with parentheses, so 0.(3) becomes 1/3 and 0.1(6) becomes 1/6. Because every step uses big integers, results are always exact and very large numerators or denominators are returned as strings rather than losing precision. Ideal for education and maths tools, recipes and unit scaling, engineering and woodworking measurements, finance, and anywhere fractions must stay exact. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 4 endpoints. This is fraction maths; for general expressions use a math-engine API and for prime factorization use a number-theory API.

Uptime

100.0%

Latency

85ms

Subs

3,435

Measure the information content of text. The analyze endpoint computes the Shannon entropy in bits per symbol, the total information in bits and bytes, the maximum possible entropy for the alphabet that was actually used, and a normalized 0–1 score that says how uniform (random-looking) the distribution is — over Unicode code points or raw UTF-8 bytes. The frequency endpoint returns the full character-frequency distribution, most common symbol first, with counts and percentages, showing control characters escaped and bytes as hex. It is exact, deterministic and runs entirely locally with no network calls, so it is instant and private. Ideal for randomness and password-quality checks, estimating how compressible data is, language and classical-cipher analysis, spotting low-variety or repetitive input, and feature extraction for text classification. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This measures information content; for password-strength scoring use a password API, for number statistics use a statistics API, and for grapheme/character counts use a text-segmentation API.

Uptime

100.0%

Latency

83ms

Subs

3,717

Convert between .env (dotenv) files and JSON, in both directions. The parse endpoint reads .env text into a clean JSON object: it skips blank lines and # comments, honours an optional leading export, unquotes single- and double-quoted values (interpreting \n, \t and \" escapes inside double quotes), strips inline comments after unquoted values, supports values that span several lines inside quotes, and can optionally expand ${VAR} and $VAR references against the variables already defined earlier in the same file — while leaving single-quoted values strictly literal. The stringify endpoint turns a JSON object back into a valid .env file, quoting only the values that actually need it and optionally prefixing every line with export for shell sourcing. Everything is computed locally and deterministically, so it is instant and private — your secrets never leave the request. Ideal for config tooling and migrations, CI/CD pipelines, converting .env to JSON for apps that want structured config (and back), and validating environment files. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This handles the dotenv format; for INI files with [sections] use an INI API, and for YAML or TOML use those APIs.

Uptime

100.0%

Latency

78ms

Subs

3,653

Deep-merge JSON objects — the operation every config and settings system needs. The merge endpoint recursively merges two objects (the second overrides the first), or a whole list of objects merged left-to-right, combining nested objects key by key rather than replacing them wholesale, with a choice of array strategy: replace (default), concat, union (concatenate and de-duplicate) or merge_index (merge element by element). A null in the overriding object can either overwrite the existing value or be ignored, so you can patch only the fields you mean to. The defaults endpoint is the inverse and just as useful: it fills in only the keys your data is missing from a defaults object, so your existing values always win — exactly how you layer a user's settings over default configuration. Everything is computed locally and deterministically, with no schema required. Ideal for configuration and feature-flag layering, settings and preference merges, combining API responses or partial updates, environment overrides, and template defaults. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This merges documents; to diff or patch them (RFC 6902) use a JSON-diff API, to flatten them use a flatten API, and to address values use a JSON-Pointer API.

Uptime

100.0%

Latency

78ms

Subs

3,319

Normalize URLs to a canonical form so you can deduplicate, compare and clean them. The canonicalize endpoint lower-cases the scheme and host, drops the default port (80 for http, 443 for https), resolves ./ and ../ path segments and fixes percent-encoding using the standard WHATWG URL parser, then applies the cleanups you choose: strip marketing and analytics tracking parameters (all utm_* plus gclid, fbclid, msclkid, yclid, mc_eid and many more), sort the remaining query parameters into a stable order, optionally drop the #fragment, and add or remove the trailing slash. It returns the canonical URL, the fully parsed components and the exact list of changes it made. The compare endpoint canonicalizes two URLs and tells you whether they point to the same resource — perfect for catching duplicate links that differ only by tracking codes, casing, port or parameter order. Everything is computed locally with no network calls, so it is instant, private and safe. Ideal for crawlers and SEO tooling, link deduplication and analytics, cache keys, bookmarking and content pipelines. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This canonicalizes the URL string; it does not fetch it or follow redirects — for link previews and unshortening use a URL-unfurl API.

Uptime

100.0%

Latency

83ms

Subs

3,435

Canonicalize email addresses so you can deduplicate accounts and catch different aliases of the same inbox. The normalize endpoint lower-cases the address and applies provider-aware rules: it strips the dots from Gmail and Googlemail local parts (because Gmail ignores them) and maps googlemail.com to gmail.com, removes +tag sub-addressing for Gmail and the many providers that support it — Outlook, Hotmail, Live, iCloud, Fastmail, Proton, Yandex, Zoho, GMX and more — and, by default, for every domain so duplicates never slip through, while reporting exactly which changes it made and which provider it detected. The compare endpoint normalizes two addresses and tells you whether they resolve to the same mailbox. Everything is computed locally and deterministically, with no DNS or network calls, so it is instant and private. Ideal for sign-up and registration dedup, fraud and abuse prevention (one person, many aliases), CRM and mailing-list hygiene, and merging customer records. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This normalizes addresses for comparison; to verify that an address actually exists and can receive mail (MX, disposable, role accounts) use an email-verification API.

Uptime

100.0%

Latency

75ms

Subs

3,885

Expand and describe RFC 5545 recurrence rules — the RRULE that powers calendar repeats. The expand endpoint takes an RRULE and a start date-time and returns the next occurrence dates, correctly handling FREQ (daily, weekly, monthly, yearly and the finer hourly/minutely/secondly), INTERVAL (every 2 weeks…), COUNT and UNTIL, BYDAY including ordinals like 2MO or -1FR (so "the last Friday of the month" or "the third Sunday of June"), BYMONTHDAY including negatives (-1 for the last day of the month), BYMONTH and WKST. The describe endpoint turns a rule into a plain-English sentence such as "every week on Monday, Wednesday and Friday, 10 times". Everything is computed locally in UTC and deterministically, so it is instant, private and identical on every machine. Ideal for scheduling and booking systems, calendar and reminder apps, billing and subscription cycles, job and report scheduling, and showing customers when something next happens. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This expands the recurrence rule; to build a downloadable .ics calendar event use an iCalendar API, and for plain date arithmetic use a date-time API.

Uptime

100.0%

Latency

85ms

Subs

4,012

Generate and solve mazes — entirely locally and reproducibly. The generate endpoint builds a perfect maze (exactly one path between any two cells, no loops) of the width and height you choose, using either a recursive-backtracker algorithm (long, winding corridors) or Prim's algorithm (more branching, shorter dead-ends), and returns it as ready-to-print ASCII art plus a compact per-cell wall-bitmask grid, with the start marked top-left and the exit bottom-right. Every maze is fully reproducible: pass a seed and you always get exactly the same maze on any machine, and the seed is returned when you omit it so you can recreate it later. The solve endpoint re-creates the maze from the same seed, width, height and algorithm and returns the shortest path from start to finish, both as an ordered list of cells and drawn onto the maze. Everything is computed locally and deterministically, so it is instant and private. Ideal for games and puzzles, procedural level generation, teaching algorithms and graph search, printable activity sheets, and creative coding. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints.

Uptime

100.0%

Latency

79ms

Subs

4,240

Generate tournament schedules — entirely locally. The roundrobin endpoint builds a full round-robin fixture list in which every participant plays every other exactly once, or twice (home and away) with double=true, using the classic circle method: it balances home and away across the rounds and, when there is an odd number of entrants, automatically gives each a bye in turn. The bracket endpoint builds a single-elimination knockout bracket: it rounds the field up to the next power of two, seeds the entrants in standard bracket order so the top seed meets the lowest and the strongest only meet in later rounds, awards the byes to the highest seeds, and lays out every round through the Final with the right names (Quarterfinal, Semifinal, Final). Pass a list of team or player names, or simply a number of participants. Everything is computed locally and deterministically, so it is instant and private. Ideal for sports leagues and apps, esports and gaming ladders, club and school competitions, hackathons and any event that needs fair fixtures. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This generates the schedule; for live scores, results and real-world fixtures use a sports data API.

Uptime

100.0%

Latency

79ms

Subs

4,854

Turn physical light into RGB colours — entirely locally. The kelvin endpoint converts a colour temperature in Kelvin into the RGB colour of a black body at that temperature: warm candle and incandescent tones below 3000 K, neutral and daylight whites around 5000–6500 K, and cool bluish light above, using Tanner Helland's widely-used approximation and returning hex, an rgb() string and a plain-English description (candlelight, warm white, neutral, daylight, cool). The wavelength endpoint converts a wavelength of visible light in nanometres (380–780 nm) into the approximate RGB colour the human eye perceives, with the natural intensity fall-off at the violet and red edges of the spectrum, and names the band (violet, blue, cyan, green, yellow, orange, red). Everything is computed locally and deterministically, so it is instant and private. Ideal for lighting and smart-bulb apps, photography and white-balance tools, data-visualisation of temperature or spectra, theming and UI accents, and science and education. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. These are perceptual approximations, not colorimetric CIE conversions; for hex/RGB/HSL conversion and palettes use a colour API.

Uptime

100.0%

Latency

77ms

Subs

3,141

Build correct CORS response headers and evaluate preflight requests — without re-reading the spec every time. The headers endpoint turns a simple policy (allowed origins, methods, request headers, whether credentials are allowed, a preflight max-age and any exposed response headers) into the exact set of Access-Control-* headers to return, and it handles the parts people get wrong: you cannot combine a wildcard origin with credentials, so it reflects the specific request origin and adds Vary: Origin instead; it omits the allow-origin header when an origin is not on your list; and it warns when a configuration would not behave as expected. The check endpoint takes an incoming request — its Origin, the (requested) method and the Access-Control-Request-Headers — and tells you whether it would pass CORS, the precise reason if it fails, and the response headers you should send back. Everything is computed locally and deterministically, so it is instant and private. Ideal for API gateways and backends, edge and serverless functions, debugging browser CORS errors, and getting a security policy exactly right. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This builds and checks the headers; it does not make a cross-origin request — to inspect a live site's security headers use a security-headers API.

Uptime

100.0%

Latency

83ms

Subs

3,380

Pricing and profitability maths as an API. The margin endpoint solves the relationships between unit cost, selling price, gross margin (a percentage of the price), markup (a percentage of the cost) and profit — give it any two of these and it works out all the rest. Price a product from a target margin, find the true margin of an existing price, convert a markup into a margin (they are not the same — the same price always has a lower margin than markup), or back out a cost from a price and markup. The breakeven endpoint computes how many units, and how much revenue, you need to sell to cover your fixed costs, given a unit price and a variable cost per unit, and returns the contribution margin and contribution-margin ratio. Negative results are reported honestly so a loss-making price is obvious. Everything is computed locally and deterministically, so it is instant and private. Ideal for e-commerce and retail pricing, quoting and sales tooling, finance and FP&A, marketplaces and POS systems, and unit-economics modelling. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This is pricing maths; for everyday percentage operations use a percentage API and for loan and interest maths use a finance-calculator API.

Uptime

100.0%

Latency

82ms

Subs

4,255

Validate, reformat and analyse MAC (EUI-48) addresses — entirely locally. The format endpoint accepts a MAC in any common notation — colon (aa:bb:cc:dd:ee:ff), hyphen (aa-bb-…), Cisco dotted (aabb.ccdd.eeff) or bare (aabbccddeeff) — and returns it in the notation you ask for plus all the others, in upper or lower case, normalising messy input into a clean canonical form. The info endpoint analyses an address: it splits the OUI (the manufacturer prefix) from the NIC portion, reports whether the address is unicast or multicast (the I/G bit) and whether it is universally or locally administered (the U/L bit), flags the broadcast address, and derives the Modified EUI-64 interface identifier and the matching IPv6 link-local address (fe80::…) per RFC 4291. Everything is computed locally and deterministically, so it is instant and private — no lookups, no third-party calls. Ideal for network automation and IPAM, switch/router and firewall tooling, device inventory and asset management, DHCP and provisioning, and IPv6 SLAAC work. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This formats and analyses the address; to look up the manufacturer behind a MAC use a MAC-vendor API.

Uptime

100.0%

Latency

79ms

Subs

4,800

Find the real client IP behind proxies, CDNs and load balancers. The client endpoint takes an X-Forwarded-For list (or an RFC 7239 Forwarded header) together with a count of proxies you trust, and returns the actual client address — stripping the trusted proxies from the right-hand side so that a spoofed left-most value cannot fool you — along with the full ordered hop chain, the left-most and right-most entries and the address family. The parse endpoint decomposes a Forwarded header into its for/by/host/proto hops, or an X-Forwarded-For header into its ordered list of addresses, stripping ports and IPv6 brackets so you get clean IPs. Getting this right matters for security: trusting the wrong entry lets clients spoof their IP, so the trusted-proxy model returns the first address you did not put there yourself. Everything is computed locally and deterministically, so it is instant and private. Ideal for reverse proxies and API gateways, rate limiting and abuse prevention, audit logging and analytics, geo and fraud checks, and any backend sitting behind a load balancer. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This parses forwarding headers to find the client IP; to geolocate that IP use an IP-geolocation API.

Uptime

100.0%

Latency

78ms

Subs

3,324

Deterministic A/B testing and feature-flag assignment — no database, no stored state. The bucket endpoint hashes a key (a user id, session or device) into a stable bucket from 0 to N-1 that never changes for that key, and can decide whether the key is inside a percentage rollout; because the decision is monotonic, raising the percentage only ever adds users, so a gradual ramp-up is sticky and no one flips back out. The variant endpoint assigns one of several weighted variants — a simple control/treatment split or any multivariate test — consistently for the same key, honouring custom weights. Mixing in an experiment name keeps independent experiments independent, and because the same inputs always produce the same answer, your client and server (and any edge function) agree on the assignment without any coordination or lookups. Hashing is FNV-1a with an avalanche mix, giving uniform, stable buckets across languages and machines. It runs entirely locally, so it is instant, deterministic and private. Ideal for feature flags and gradual rollouts, A/B and multivariate experiments, canary releases, holdouts and kill-switches, and consistent UI bucketing across web and mobile. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This assigns experiments deterministically; to test whether a result is statistically significant use a statistics API.

Uptime

100.0%

Latency

79ms

Subs

3,216

Parse and build HTTP Content-Disposition headers (RFC 6266, with RFC 5987 filename* encoding). The parse endpoint reads a header into its disposition type (attachment, inline or form-data), its filename — correctly decoding the extended filename*=UTF-8''… form and preferring it over a plain filename exactly as the specification requires — the form-data field name, and any remaining parameters. The build endpoint assembles a correct header from simple fields and, when a filename contains non-ASCII characters (accents, emoji, CJK), automatically emits both an ASCII fallback filename and the percent-encoded filename*, so every browser shows the right download name while older clients still work. Everything is computed locally and deterministically, so it is instant and private — no file is ever fetched or stored. Ideal for file-download and upload endpoints, object storage and CDNs, content gateways and proxies, email and multipart handling, and debugging why a download is mis-named. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This builds and parses the header string itself; it does not serve a file.

Uptime

100.0%

Latency

80ms

Subs

3,871

Generate famous integer sequences and test membership, with exact big-integer maths. The generate endpoint returns the first N terms of a sequence — Fibonacci, Lucas, prime numbers, triangular, square, cube, factorial, Catalan, pentagonal and tetrahedral numbers, plus parameterised arithmetic (a start and a step), geometric (a start and a ratio) and powers (any base). The contains endpoint tells you whether a given number belongs to a sequence — is 233 a Fibonacci number, is 21 triangular, is 97 prime, is 720 a factorial — using fast closed-form tests for primes, squares, cubes, triangular, pentagonal and Fibonacci numbers and an exact search for the rest, and it returns the term index where it is known. Because everything is computed with arbitrary-precision integers, terms beyond the usual floating-point limit are returned exactly as decimal strings and never overflow. It runs entirely locally, so it is instant, deterministic and private. Ideal for education and maths tooling, coding challenges and puzzles, test-data generation, recreational mathematics and number-theory experiments. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This generates and tests integer sequences; to factorize a single number or get its divisors use a number-theory API.

Uptime

100.0%

Latency

80ms

Subs

3,656

Parse and build HTTP Cache-Control headers (RFC 9111). The parse endpoint turns a Cache-Control header into structured, named directives — public and private, no-store, no-cache, no-transform, max-age and s-maxage, must-revalidate and proxy-revalidate, immutable, stale-while-revalidate, stale-if-error, min-fresh and max-stale — together with a quick summary: whether the response is cacheable, whether it must be revalidated before use, its visibility (public or private) and its max-age in seconds. The build endpoint assembles a correct, canonically-ordered header from simple boolean and numeric fields, validating that the second-based directives are non-negative integers and quoting field-list forms of no-cache and private. Everything is computed locally and deterministically, so it is instant and private. Ideal for CDN and edge configuration, caching proxies and reverse proxies, API responses and static-asset tuning, and debugging why a response is (or is not) being cached. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This builds and parses the header string itself; it does not fetch a URL.

Uptime

100.0%

Latency

86ms

Subs

3,244

Generate n-grams from text, with frequency counts — entirely locally. The ngrams endpoint breaks text into contiguous sequences of n tokens and returns each distinct n-gram with how often it occurs, ranked by frequency: word n-grams (unigrams, bigrams, trigrams and beyond) for phrase and collocation analysis, or character n-grams (shingles) for fuzzy matching, language detection and indexing. The range endpoint produces every size from a minimum to a maximum in a single call (for example 1–3 grams), which is exactly what you need to build feature vectors. Choose word or character mode, whether to lower-case first, and a top-N limit to keep only the most frequent. Word tokenization is Unicode-aware and keeps internal apostrophes and hyphens (don't, well-known) as single tokens. Everything runs locally and deterministically, so it is fast and private. Ideal for text mining and NLP feature extraction, language modelling and autocomplete, search indexing and shingling, plagiarism and similarity detection, and keyword and collocation analysis. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This produces n-grams and counts; for extractive summaries and keywords use a summarize API and for grapheme/character counting use a text-segmentation API.

Uptime

100.0%

Latency

84ms

Subs

3,735

Parse and build RFC 8288 HTTP Link headers (Web Linking). The parse endpoint turns a Link header into a structured list — each link with its URI, its rel relation(s) and any target attributes (title, type, hreflang, media, anchor) — and also returns a handy rel→uri map, so you can grab the next, prev, first and last URLs for API pagination in a single step. It correctly handles the awkward parts: multiple comma-separated links, commas inside angle-bracketed URIs, quoted parameter values, multiple space-separated rel tokens, and RFC 8187 extended values. The build endpoint assembles a correct Link header from one or more link objects (or a single uri + rel with optional attributes), quoting values only where required. Everything is computed locally and deterministically, so it is instant and private. Ideal for paginated REST APIs and clients, hypermedia and HATEOAS, HTTP preload/prefetch hints, feed and alternate-format discovery, proxies and gateways. Pure local computation — no key, no third-party service, instant. Live, nothing stored. 3 endpoints. This builds and parses the Link header string itself; it does not fetch a URL.

Uptime

100.0%

Latency

76ms

Subs

4,706