{
  "api": "articles",
  "title": "Articles",
  "description": "Guides, explainers and essays about free data, the APIs and the philosophy behind GratisAPI.",
  "emoji": "📝",
  "license": "GPL-2.0-or-later",
  "count": 120,
  "self": "https://gratisapi.com/api/articles/index",
  "endpoints": {
    "list": "https://gratisapi.com/api/articles/index",
    "item": "https://gratisapi.com/api/articles/{id}"
  },
  "fields": [
    "author",
    "body",
    "category",
    "date",
    "id",
    "reading_time_min",
    "summary",
    "tags",
    "title",
    "try_api",
    "word_count"
  ],
  "results": [
    {
      "id": "freedom-manifesto-for-gratis-apis",
      "title": "A Manifesto for Gratis APIs",
      "category": "Philosophy",
      "author": "The GratisAPI Team",
      "date": "2025-05-28",
      "tags": [
        "manifesto",
        "principles",
        "gratisapi"
      ],
      "summary": "A concise statement of the principles behind GratisAPI: free in both senses, open, private, durable, and built to be trusted.",
      "body": "This is a short statement of what we believe an open data API should be, and what we are trying to make GratisAPI into. It is a manifesto in the modest sense of a list of principles we are willing to be held to.\n\nAn API should be gratis in earnest. Free should mean free, with no fee, no paid tier hiding the real functionality, and no invoice waiting after a trial. If it costs money, it should say so plainly rather than lure with a zero that later turns positive.\n\nAn API should be libre. The data and the code that produces it should be openly licensed, so anyone may study how it works, change it, run their own copy, and share their version. Freedom that cannot be exercised is only a slogan, so the source must actually be available.\n\nAn API should demand nothing to begin. No key, no account, no email, no credit card. The first request should be possible in a single line, before curiosity cools. Barriers to entry are a tax on the very exploration that makes technology worthwhile.\n\nAn API should not watch you. It should set no trackers, keep no profiles, and forget you as soon as it has answered. What it never collects, it can never leak, sell, or be compelled to reveal. Privacy should be a property of the design, not a promise in a policy.\n\nAn API should be built to last and to be left. Simple, static, cheap to serve, and fully mirrorable, so that it can endure on small means and so that anyone can carry it forward if we falter. The exit door should always be open, because a standing exit is what makes a promise trustworthy.\n\nAnd an API should treat public data as the public good it is, offered like water from a well rather than rented from a landlord. These principles are what GratisAPI aspires to. Where we fall short, the freedoms we grant are your remedy: take the code, and build it better.",
      "word_count": 340,
      "reading_time_min": 2,
      "try_api": "quotes",
      "url": "https://gratisapi.com/api/articles/freedom-manifesto-for-gratis-apis"
    },
    {
      "id": "world-hindu-pantheon",
      "title": "The Hindu Pantheon",
      "category": "Culture",
      "author": "The GratisAPI Team",
      "date": "2025-05-20",
      "tags": [
        "mythology",
        "hindu"
      ],
      "summary": "Hinduism embraces a vast array of gods and goddesses expressing a single divine reality. This article introduces its principal deities.",
      "body": "The Hindu pantheon is one of the richest and most complex in the world, populated by a great many gods and goddesses. Yet many Hindus understand these countless deities as different faces of a single ultimate reality, called Brahman, so that the tradition can be seen as both wonderfully diverse and deeply unified.\n\nAt the heart of much Hindu worship stands a great triad. Brahma is the creator who brings the universe into being, Vishnu is the preserver who sustains and protects it, and Shiva is the destroyer whose power clears away the old to make room for renewal. Together they express the eternal cycle of creation, preservation, and dissolution.\n\nVishnu is especially beloved for his avatars, earthly forms he takes to restore balance when the world falls into disorder. The most famous are Rama, the noble prince of the epic Ramayana, and Krishna, the playful and profound teacher of the Bhagavad Gita. Their stories are among the most cherished in all of world literature.\n\nGoddesses hold immense importance in their own right. Lakshmi bestows wealth and fortune, Saraswati grants knowledge and the arts, and the fierce Durga and Kali embody the protective and destructive power of the divine feminine. Ganesha, the elephant headed son of Shiva, is adored across India as the remover of obstacles and is invoked at the start of new ventures.\n\nThese deities are woven into daily life through festivals, temples, and home shrines, their images instantly recognisable across the subcontinent and beyond. The GratisAPI catalogue offers datasets exploring mythologies and their deities, a respectful starting point for study, creative work, or projects that draw on this vast and living tradition.",
      "word_count": 275,
      "reading_time_min": 1,
      "try_api": "colors",
      "url": "https://gratisapi.com/api/articles/world-hindu-pantheon"
    },
    {
      "id": "science-biomes-of-earth",
      "title": "The Biomes of Earth",
      "category": "Science",
      "author": "The GratisAPI Team",
      "date": "2025-05-06",
      "tags": [
        "ecology",
        "biomes",
        "environment"
      ],
      "summary": "Biomes are the great communities of life that blanket the planet, each shaped by its climate into distinctive forests, grasslands, deserts, and more.",
      "body": "Zoom out from any single forest or meadow and you begin to see that life on Earth arranges itself into vast regional patterns. These large scale communities, defined by their climate and the plants and animals adapted to it, are called biomes. They are the broadest way ecologists divide up the living world.\n\nClimate is the great architect of biomes, especially temperature and rainfall. Near the equator, warmth and heavy rain produce tropical rainforests, the most biologically rich places on the planet, teeming with more species than anywhere else. Where rain is seasonal, tropical grasslands called savannas spread out, dotted with grazing herds. In the dry belts around the tropics lie the deserts, where little rain falls and plants and animals have evolved remarkable tricks to conserve water.\n\nMoving toward the poles, temperate regions host their own biomes. Temperate forests of oak and maple shed their leaves each autumn, while temperate grasslands, known as prairies or steppes, once fed enormous herds of bison. Further north stretches the taiga, a great belt of coniferous evergreen forest, and beyond it the treeless tundra, where the ground stays frozen and only hardy mosses and shrubs survive the brief, cool summers.\n\nBiomes are not limited to land. Aquatic biomes, covering most of the planet, include freshwater lakes and rivers as well as the vast marine realm of oceans, coral reefs, and estuaries. Coral reefs in particular rival rainforests for their density of life.\n\nUnderstanding biomes helps us see how climate shapes life and why changes to that climate ripple through entire ecosystems. As global temperatures shift, the boundaries between biomes are already moving, reshaping where different communities of life can thrive.",
      "word_count": 277,
      "reading_time_min": 1,
      "try_api": "animals",
      "url": "https://gratisapi.com/api/articles/science-biomes-of-earth"
    },
    {
      "id": "freedom-ethics-of-rate-limiting",
      "title": "The Ethics of Rate Limiting",
      "category": "Philosophy",
      "author": "The GratisAPI Team",
      "date": "2025-03-19",
      "tags": [
        "rate-limiting",
        "ethics",
        "access"
      ],
      "summary": "Rate limiting can protect a shared resource or quietly ration access for profit; the difference lies in its purpose and honesty.",
      "body": "Rate limiting, restricting how many requests a user may make in a given time, is nearly universal in the world of APIs. It can be entirely justified or quietly coercive, and the difference lies in why it is done. Examining that difference is a small exercise in the ethics of shared resources.\n\nThere is a legitimate version. A public service has finite capacity, and a single heavy user, whether malicious or merely careless, can degrade the experience for everyone else. Limiting the rate of requests protects the commons, ensuring that one actor cannot monopolize a shared resource. Understood this way, rate limiting is like a fair-use rule at a public well: draw what you need, and leave enough for the next person.\n\nThere is also a coercive version. Many commercial APIs set their free-tier limits deliberately low, not to protect capacity but to frustrate you into paying. The limit is a sales tool disguised as a technical safeguard, calibrated to be just painful enough to push you toward a subscription. Here the scarcity is manufactured, and the ethics are quite different.\n\nThe test is honesty of purpose. Does the limit exist to keep a genuinely shared resource healthy, or to create artificial pain that a payment relieves? Is it set generously, at the level real protection requires, or stingily, at the level that maximizes conversions? A protective limit is a courtesy to other users; a coercive one is pressure dressed as a courtesy.\n\nTransparency matters too. Fair rate limiting is clearly explained, applied evenly, and set no tighter than necessary. Users can understand it and plan around it. Coercive limiting is often vague, precisely because its real logic would not survive being stated plainly.\n\nGratisAPI, being static and cheap to serve, has little need to ration access at all, and any limits exist only to keep the service healthy for everyone, never to sell you a way around them. When protecting a resource and extracting a payment point in different directions, we choose protection.",
      "word_count": 334,
      "reading_time_min": 2,
      "try_api": "elements",
      "url": "https://gratisapi.com/api/articles/freedom-ethics-of-rate-limiting"
    },
    {
      "id": "reference-http-headers",
      "title": "HTTP Headers Explained",
      "category": "Reference",
      "author": "The GratisAPI Team",
      "date": "2025-03-12",
      "tags": [
        "http",
        "headers",
        "web"
      ],
      "summary": "HTTP headers carry the extra information that accompanies web requests and responses.",
      "body": "An HTTP message is more than a method and a body. Alongside them travels a collection of headers, which are name and value pairs that carry extra information about the request or response. Headers are where much of the real coordination between a browser and a server happens, quietly shaping how content is delivered.\n\nRequest headers describe the client and what it wants. The Host header names the site being requested, which lets one server host many sites. The User-Agent header identifies the browser or program making the request. The Accept header states which content types the client can handle, and the Authorization header carries credentials that prove who the client is. Together these let the server tailor its response.\n\nResponse headers describe what the server is sending back. The Content-Type header states the MIME type of the body so the client knows how to interpret it. The Content-Length header gives its size. The Location header tells the client where to go during a redirect, working alongside the status code. These headers make the raw body usable.\n\nA large group of headers governs caching and performance. The Cache-Control header tells clients and intermediaries how long they may reuse a response, sparing the server from repeated work. Related headers let a client ask whether its cached copy is still fresh, so unchanged content need not be sent again.\n\nOther headers handle security. Headers can instruct a browser to use only secure connections, restrict which sources of scripts are trusted, or control cross origin requests. These modern headers have become essential for protecting users.\n\nGratisAPI provides a reference at /api/http-headers/index.json, where each entry names a header, notes whether it appears in requests or responses, and describes its purpose. It is a useful companion when debugging traffic or building tools that inspect it. Learning to read headers turns an opaque exchange into a readable conversation, and it is often the fastest path to understanding why a request behaved the way it did.",
      "word_count": 329,
      "reading_time_min": 2,
      "try_api": "http-headers",
      "url": "https://gratisapi.com/api/articles/reference-http-headers"
    },
    {
      "id": "world-birthstones",
      "title": "Birthstones Month by Month",
      "category": "Culture",
      "author": "The GratisAPI Team",
      "date": "2025-03-11",
      "tags": [
        "gemstones",
        "tradition"
      ],
      "summary": "Each month of the year is linked to a birthstone, from January's garnet to December's turquoise. This article explores the tradition and its gems.",
      "body": "The custom of associating each month with a particular gemstone, known as a birthstone, is a charming tradition that blends folklore, jewellery, and personal identity. Many people wear their birthstone as a way of carrying a small piece of meaning tied to the month they were born.\n\nThe modern list runs through the year with a distinctive gem for each month. January is garnet, February amethyst, March aquamarine, April the diamond, May emerald, and June often the pearl. The second half of the year brings July's ruby, August's peridot, September's sapphire, October's opal, November's topaz, and December's turquoise, though several months have alternative stones.\n\nThe tradition has deep and tangled roots. Some trace it back to the twelve stones on the breastplate of the high priest described in the Hebrew Bible, later linked to the months and the signs of the zodiac. Over the centuries the associations shifted, and the list most people use today was formalised by jewellers in the early twentieth century to standardise the custom.\n\nEach stone carries its own supposed powers and meanings, drawn from centuries of legend. Emeralds were once thought to reveal the truth, rubies to protect against harm, and amethysts to guard against overindulgence. Whether or not anyone takes these old beliefs seriously, they add a layer of story to a beautiful object.\n\nBirthstones remain hugely popular in the jewellery trade, offering a ready made way to make a gift feel personal. The GratisAPI birthstones dataset at /api/birthstones/index.json lists each month with its associated stone and traditional meanings, a tidy reference for building gift finders, quizzes, or apps that celebrate this enduring tradition.",
      "word_count": 270,
      "reading_time_min": 1,
      "try_api": "birthstones",
      "url": "https://gratisapi.com/api/articles/world-birthstones"
    },
    {
      "id": "howto-self-hosting",
      "title": "Mirroring or Self-Hosting GratisAPI",
      "category": "Tutorials",
      "author": "The GratisAPI Team",
      "date": "2025-02-26",
      "tags": [
        "self-hosting",
        "github-pages",
        "open-data"
      ],
      "summary": "Because GratisAPI is fully open and static, you can clone, mirror, or host your own copy anywhere in minutes.",
      "body": "GratisAPI is both gratis and libre. The data is licensed under the GPL and the entire project is a collection of static files, which means you are free to mirror it, host your own instance, or fork it and extend it. There is nothing to unlock and no server software to license.\n\nThe simplest mirror is a clone. Clone the repository from GitHub and you have every JSON file locally. Since the API is just static files under an api directory, you can serve that folder with any web server. A one-line command like python3 -m http.server from the project root will serve the files for local development, and your code can point at http://localhost:8000/api/quotes/index.json instead of the public URL.\n\nFor a permanent instance, deploy the static files to any static host: GitHub Pages, GitLab Pages, Netlify, Cloudflare Pages, or an S3 bucket behind a CDN. Because there is no build step required to serve the data and no backend, deployment is simply copying files. Point your host at the api directory and the endpoints work exactly as they do on the original.\n\nWhy self-host? A mirror insulates you from any upstream changes or downtime, gives you full control over caching and custom domains, and lets you add or modify collections for your own needs. If you fork the project, you can add new datasets by dropping in JSON files that follow the same shape, then regenerate the index and OpenAPI spec so your additions are discoverable.\n\nRespect the GPL license when you redistribute: keep the license file and make your source available under the same terms. Beyond that, the project is designed to be copied. The whole point of a gratis, static, open-data API is that no one is locked in. If you depend on GratisAPI in production, running your own mirror is the most reliable way to use it, and it takes only minutes to set up.",
      "word_count": 319,
      "reading_time_min": 2,
      "try_api": "quotes",
      "url": "https://gratisapi.com/api/articles/howto-self-hosting"
    },
    {
      "id": "science-human-organ-systems",
      "title": "The Human Organ Systems",
      "category": "Science",
      "author": "The GratisAPI Team",
      "date": "2025-02-11",
      "tags": [
        "biology",
        "anatomy",
        "human-body"
      ],
      "summary": "The human body is organized into interconnected organ systems, each a team of organs working together to keep us alive.",
      "body": "The human body is a marvel of organization. Trillions of cells group into tissues, tissues form organs, and organs cooperate in larger teams called organ systems. Each system handles a broad task, and together the roughly eleven systems keep the body alive and functioning.\n\nSeveral systems work to supply and distribute what the body needs. The respiratory system, centered on the lungs, brings in oxygen and expels carbon dioxide. The circulatory system, driven by the heart, pumps blood through a vast network of vessels to carry oxygen, nutrients, and waste. The digestive system breaks food down into absorbable nutrients, while the urinary system filters the blood and removes waste as urine.\n\nOther systems provide structure and movement. The skeletal system of bones gives the body its frame and protects delicate organs, and the muscular system pulls on those bones to produce every movement, from a heartbeat to a sprint. Wrapping it all is the integumentary system, the skin, hair, and nails that shield us from the outside world.\n\nControl and defense fall to still other systems. The nervous system, made of the brain, spinal cord, and nerves, senses the environment and coordinates rapid responses. The endocrine system uses hormones to send slower, longer lasting chemical signals that regulate growth, metabolism, and mood. The immune, or lymphatic, system defends against invaders, and the reproductive system carries out the making of new life.\n\nNo system works in isolation. Breathing depends on muscles, delivering oxygen depends on blood, and all of it is coordinated by nerves and hormones. This constant cooperation keeps the internal environment stable, a balance called homeostasis. You can browse the major body systems and the organs within them through the GratisAPI endpoint at /api/body-systems/index.json.",
      "word_count": 285,
      "reading_time_min": 1,
      "try_api": "body-systems",
      "url": "https://gratisapi.com/api/articles/science-human-organ-systems"
    },
    {
      "id": "reference-file-formats",
      "title": "File Formats Explained",
      "category": "Reference",
      "author": "The GratisAPI Team",
      "date": "2025-01-20",
      "tags": [
        "file-formats",
        "data",
        "files"
      ],
      "summary": "A file format defines how data is arranged inside a file so that programs can read it correctly.",
      "body": "A file is just a sequence of bytes, and by itself that sequence means nothing. A file format is the agreed convention that gives those bytes meaning, telling a program how to interpret them as an image, a document, a sound, or structured data. Without formats, files would be unreadable noise.\n\nFormats fall into two broad kinds. Text formats store data as human readable characters, so you can open them in any editor and understand them. Examples include plain text, CSV for tabular data, JSON and XML for structured data, and HTML for web pages. Binary formats store data as raw bytes optimized for a program rather than a person, which makes them compact and fast but unreadable without the right software. Images, audio, video, and compiled programs are usually binary.\n\nMany formats begin with a signature, a few bytes at the start that identify the type. This magic number lets programs recognize a file's true format even if its name is wrong. The file extension at the end of a name is only a hint; the signature is the real evidence, which is why renaming a file does not change what it actually is.\n\nFormats also differ in how they handle size. Some compress their data to save space, and compression can be lossless, preserving every detail, or lossy, discarding some information for a smaller file. Photographs often use lossy compression because slight imperfections go unnoticed, while archives use lossless compression because every byte must survive.\n\nChoosing a format means weighing readability, size, and compatibility. A text format is great for data you must inspect or edit, while a binary format is better when efficiency matters most.\n\nGratisAPI provides a reference at /api/file-formats/index.json, where each entry names a format, its typical extension, and a description of its use. It pairs naturally with the MIME types dataset, since formats and MIME types describe the same thing from different angles. Understanding formats explains why files open in particular programs and why the bytes inside them are arranged as they are.",
      "word_count": 339,
      "reading_time_min": 2,
      "try_api": "file-formats",
      "url": "https://gratisapi.com/api/articles/reference-file-formats"
    },
    {
      "id": "freedom-static-hosting-as-freedom",
      "title": "Static Hosting as a Form of Freedom",
      "category": "Philosophy",
      "author": "The GratisAPI Team",
      "date": "2025-01-15",
      "tags": [
        "static-hosting",
        "architecture",
        "freedom"
      ],
      "summary": "Serving an API as static files brings a surprising amount of freedom: low cost, easy mirroring, durability, and independence.",
      "body": "There is a quiet radicalism in serving an API as nothing but static files. No application server, no database, no dynamic backend, just precomputed data sitting in files that any web server can hand out. This humble architecture turns out to carry a surprising amount of freedom.\n\nThe first freedom is from cost. Static files are extraordinarily cheap to serve. They can be cached aggressively, distributed across content networks, and handled by inexpensive or even free hosting. Low cost is not merely convenient; it is what makes a no-fee, no-key promise sustainable over the long term rather than a subsidy waiting to be withdrawn.\n\nThe second freedom is from lock-in. Static files depend on no particular vendor's proprietary platform. They can be moved from one host to another, served from your own machine, or copied to a dozen mirrors. There is no special runtime to reproduce, no managed database to migrate. If a host disappears, you simply put the files somewhere else.\n\nThe third freedom is durability. A static site has almost nothing to break. There is no server process to crash, no database to corrupt, no dependency to fall out of date and open a security hole. Files served today will serve identically in ten years, which suits a project meant to last.\n\nThe fourth freedom is mirrorability. Because the whole API is just files, anyone can download the entire thing and host their own copy. This makes the right to fork tangible and cheap. The data cannot be held hostage by a single point of control when copies can multiply freely.\n\nStatic hosting is not suitable for everything; genuinely interactive or personalized services need more. But for open, public data that changes slowly, it is close to ideal. GratisAPI is static by design, and that design is itself an expression of the freedom we are trying to provide.",
      "word_count": 310,
      "reading_time_min": 2,
      "try_api": "birds",
      "url": "https://gratisapi.com/api/articles/freedom-static-hosting-as-freedom"
    },
    {
      "id": "world-greek-alphabet",
      "title": "The Greek Alphabet",
      "category": "Culture",
      "author": "The GratisAPI Team",
      "date": "2025-01-14",
      "tags": [
        "alphabet",
        "greek"
      ],
      "summary": "The Greek alphabet gave the world its very word for alphabet and underpins science and mathematics. This article introduces its twenty-four letters.",
      "body": "The Greek alphabet is one of the most influential writing systems ever devised. Its twenty-four letters, from alpha to omega, have been in continuous use for around three thousand years and lie at the root of the Latin and Cyrillic scripts used by much of the world today.\n\nThe alphabet was a genuine breakthrough. Adapting an earlier Phoenician script, the Greeks made the crucial innovation of writing down vowels as separate letters, not just consonants. This made the script far easier to read and learn, and it is often called the first true alphabet for exactly this reason. The very word alphabet comes from its first two letters, alpha and beta.\n\nMany of the letters are instantly familiar because they appear everywhere in science and mathematics. Pi names the ratio of a circle's circumference to its diameter, delta signals change, sigma indicates a sum, and lambda, mu, and omega crowd the pages of physics textbooks. Greek letters give specialists a rich supply of ready made symbols.\n\nThe letters also saturate everyday culture. Alpha and omega together mean the beginning and the end, a phrase drawn from the alphabet's first and last letters. University fraternities and sororities name themselves with Greek letters, and countless products and brands borrow their prestige.\n\nBeyond its many borrowings, the alphabet remains the living script of the Greek language, used daily by millions of people. Learning it opens a window onto classical literature, the New Testament, and the origins of Western science. The GratisAPI Greek alphabet dataset at /api/greek-alphabet/index.json lists each letter with its name and both upper and lower case forms, a handy reference for building learning tools, quizzes, or projects that draw on this remarkable script.",
      "word_count": 282,
      "reading_time_min": 1,
      "try_api": "greek-alphabet",
      "url": "https://gratisapi.com/api/articles/world-greek-alphabet"
    },
    {
      "id": "howto-openapi-swagger",
      "title": "Using the OpenAPI Spec and Swagger UI",
      "category": "Tutorials",
      "author": "The GratisAPI Team",
      "date": "2025-01-14",
      "tags": [
        "openapi",
        "swagger",
        "documentation"
      ],
      "summary": "Explore GratisAPI endpoints interactively and generate clients using the published OpenAPI specification.",
      "body": "GratisAPI publishes a machine-readable OpenAPI specification that describes its endpoints, response shapes, and metadata. This document unlocks interactive documentation, client generation, and validation, all from a single source of truth.\n\nThe OpenAPI file is linked from the root index at /api/index.json under the openapi field, and the project's documentation site presents it through Swagger UI. Swagger UI renders the spec as a browsable page where each endpoint is listed with its description and example responses. You can expand an operation and use the Try it out button to send a live request and see the actual JSON come back, which is a fast way to learn an endpoint before writing any code.\n\nBecause the spec is standard OpenAPI, it works with the broad ecosystem of tools built around that format. You can feed it to a code generator such as openapi-generator to produce a typed client library in your language of choice, saving you from writing request and model code by hand. You can import it into API testing tools like Postman or Insomnia to get a ready-made collection of requests. You can also use it to validate that responses match the documented schema in your test suite.\n\nReading the spec directly is useful too. It lists every collection, the structure of each record, and the URL patterns, so it doubles as a concise catalog of what GratisAPI offers. Since the endpoints require no authentication, the spec has no security schemes to configure; you point a tool at it and go.\n\nKeeping documentation in an OpenAPI file rather than prose means the description stays accurate and testable as the API grows. For consumers, it lowers the barrier to entry: explore interactively in Swagger UI, generate a client in seconds, and trust that the documented shapes match what the static files actually return.",
      "word_count": 302,
      "reading_time_min": 2,
      "try_api": "colors",
      "url": "https://gratisapi.com/api/articles/howto-openapi-swagger"
    },
    {
      "id": "howto-no-pagination",
      "title": "Why GratisAPI Has No Pagination (and How to Work with Full Datasets)",
      "category": "Tutorials",
      "author": "The GratisAPI Team",
      "date": "2024-11-18",
      "tags": [
        "design",
        "datasets",
        "performance"
      ],
      "summary": "Understand the deliberate choice to serve whole collections at once, and how to handle them efficiently on the client.",
      "body": "Many APIs split large results across pages, forcing clients to make repeated requests with offset and limit parameters. GratisAPI deliberately does not. Each collection is served as a single static JSON file containing every record, and this is a feature, not an oversight.\n\nThe reason is the architecture. GratisAPI is a set of plain files hosted on GitHub Pages with no server-side code to run queries or slice results. There is no backend that could compute a page on demand. Instead, the whole dataset ships at once from a URL like /api/countries/index.json, and the client works with it locally. Because the collections are curated and modest in size, downloading a complete file is fast and cheap, and it happens only once.\n\nThis approach has real advantages. A single request means one round trip instead of many, which is often faster overall than paging. Once the data is in memory, filtering, sorting, searching, and paginating become instant local operations with no further network calls. You are never rate-limited mid-scroll, and you never juggle cursor tokens.\n\nTo work with a full dataset, fetch it once and keep it in a variable or in state. Then apply array methods to shape it. To show a page, use slice with a computed offset. To search, use filter. To order, use sort. For example, to display twenty records at a time you slice the array by page index, all without touching the server again.\n\nIf a collection ever grew large enough to matter, you could load it once and cache it in localStorage or a service worker, so even the initial download is amortized across visits. But in practice the datasets are small enough that the whole model just works. Embracing the full-dataset design leads to simpler code: no pagination state machine, no loading spinners between pages, just one fetch and then fast, offline-style interaction with the complete collection.",
      "word_count": 314,
      "reading_time_min": 2,
      "try_api": "countries",
      "url": "https://gratisapi.com/api/articles/howto-no-pagination"
    },
    {
      "id": "howto-error-handling",
      "title": "Handling Errors and Missing Records Gracefully",
      "category": "Tutorials",
      "author": "The GratisAPI Team",
      "date": "2024-10-30",
      "tags": [
        "javascript",
        "errors",
        "reliability"
      ],
      "summary": "Write defensive code that survives network failures, missing endpoints, and absent fields when consuming GratisAPI.",
      "body": "Even a keyless, rate-limit-free API can fail for reasons outside its control: a dropped connection, a mistyped URL, or a record that lacks a field you expected. Robust code anticipates these cases rather than assuming every request succeeds.\n\nStart with the request itself. In the browser, fetch does not reject on HTTP error statuses, so always check response.ok before parsing. A request for a nonexistent endpoint, such as a misspelled collection name, returns a 404 that fetch happily resolves:\n\nconst res = await fetch(url);\nif (!res.ok) {\n  throw new Error(`Request failed with status ${res.status}`);\n}\nconst data = await res.json();\n\nWrap the whole thing in try/catch so both network errors and JSON parse failures are handled in one place. Show the user a clear fallback message instead of leaving the interface blank or broken.\n\nNext, guard against missing records. When you fetch a single item by id, the file may not exist if the id is wrong, which again surfaces as a 404. Treat that as a distinct case and tell the user the record was not found rather than showing an error meant for real failures.\n\nFinally, be defensive about individual fields. Even within a valid collection, do not assume every record has every property. Use optional chaining and sensible defaults, for example record?.author ?? \"Unknown\", so a single incomplete entry does not crash your rendering loop. When iterating, skip or flag records that fail validation instead of letting one bad item break the whole page.\n\nA good pattern is a small wrapper function that performs the fetch, checks the status, parses the body, and returns either the data or a clear error object your calling code can branch on. Centralizing this logic keeps every call site clean and consistent. Because GratisAPI is simple and stable, these safeguards are lightweight, but they turn a fragile demo into something you can ship with confidence.",
      "word_count": 314,
      "reading_time_min": 2,
      "try_api": "elements",
      "url": "https://gratisapi.com/api/articles/howto-error-handling"
    },
    {
      "id": "science-amino-acids-and-proteins",
      "title": "Amino Acids and Proteins",
      "category": "Science",
      "author": "The GratisAPI Team",
      "date": "2024-10-17",
      "tags": [
        "biology",
        "biochemistry",
        "proteins"
      ],
      "summary": "Amino acids are the building blocks that link together to form proteins, the molecular machines that run nearly every process in living cells.",
      "body": "Proteins do most of the work inside living things. They build tissues, speed up chemical reactions, carry oxygen, fight infection, and relay signals. Yet for all their variety, every protein is assembled from the same small set of building blocks: the amino acids.\n\nThere are twenty standard amino acids used to build proteins in living organisms. Each one shares a common core structure, a central carbon atom bonded to an amino group, an acid group, and a hydrogen, but each carries a distinct side chain that gives it a unique character. Some side chains are water loving, others water repelling, some carry electric charge, and these differences determine how the finished protein behaves.\n\nAmino acids link together like beads on a string through bonds called peptide bonds, forming long chains. The particular sequence of amino acids in a chain is dictated by the genetic code stored in DNA. That sequence is everything, because the chain does not stay stretched out. It folds spontaneously into a precise three dimensional shape, and this shape determines the protein's function. A misfolded protein can fail entirely or even cause disease.\n\nFor humans, nine of the twenty amino acids are considered essential, meaning our bodies cannot manufacture them and we must obtain them from food. Proteins from animal sources generally contain all nine, while plant foods can be combined to supply the full set. The remaining amino acids are termed non essential because our cells can build them as needed.\n\nThe elegance of the system is that just twenty building blocks, arranged in different orders and lengths, can create the countless proteins that make life possible, from the keratin in hair to the enzymes digesting your last meal. You can explore the twenty amino acids and their properties through the GratisAPI endpoint at /api/amino-acids/index.json.",
      "word_count": 299,
      "reading_time_min": 1,
      "try_api": "amino-acids",
      "url": "https://gratisapi.com/api/articles/science-amino-acids-and-proteins"
    },
    {
      "id": "howto-browser-caching",
      "title": "Caching GratisAPI Responses in the Browser",
      "category": "Tutorials",
      "author": "The GratisAPI Team",
      "date": "2024-09-25",
      "tags": [
        "javascript",
        "caching",
        "performance"
      ],
      "summary": "Speed up repeat visits by caching GratisAPI data with localStorage, the Cache API, or a service worker.",
      "body": "GratisAPI endpoints are static files that change only when the project is redeployed, which makes them excellent candidates for aggressive client-side caching. Caching cuts repeat load times and reduces needless bandwidth.\n\nThe simplest option is localStorage. After the first fetch, store the JSON string keyed by URL, and on later loads read from storage before hitting the network:\n\nasync function getCached(url) {\n  const hit = localStorage.getItem(url);\n  if (hit) return JSON.parse(hit);\n  const res = await fetch(url);\n  const text = await res.text();\n  localStorage.setItem(url, text);\n  return JSON.parse(text);\n}\n\nThis works well for small collections. To avoid serving stale data forever, store a timestamp alongside the value and treat entries older than a chosen window as expired, re-fetching when needed. Since the data only changes on redeploy, a generous expiry such as a day is usually safe.\n\nFor larger payloads or offline support, the Cache API is a better fit. It stores full Response objects and is designed to work inside a service worker. A service worker can intercept requests to GratisAPI and serve them from the cache first, falling back to the network on a miss. A stale-while-revalidate strategy returns the cached copy immediately for speed while quietly refreshing it in the background.\n\nYou can also lean on the browser's own HTTP cache. GitHub Pages serves these files with cache-friendly headers and ETags, so a normal fetch may already be satisfied from cache without any code on your part. Adding an explicit layer simply gives you more control over expiry and offline behavior.\n\nWhichever method you choose, remember to provide a way to clear the cache during development so you always see fresh data after a redeploy. With sensible caching, a GratisAPI-powered page loads instantly on return visits while still respecting the API's static nature.",
      "word_count": 292,
      "reading_time_min": 1,
      "try_api": "planets",
      "url": "https://gratisapi.com/api/articles/howto-browser-caching"
    },
    {
      "id": "world-religions-overview",
      "title": "An Overview of World Religions",
      "category": "Culture",
      "author": "The GratisAPI Team",
      "date": "2024-09-23",
      "tags": [
        "religion",
        "culture"
      ],
      "summary": "Billions of people follow the world's major faiths, from Christianity to Buddhism. This article offers a brief, respectful overview of the largest traditions.",
      "body": "Religion has shaped human civilisation for as long as records exist, guiding morality, inspiring art, and binding communities together. Today the majority of people identify with one of a handful of major traditions, though thousands of smaller faiths also flourish around the world.\n\nChristianity is the largest religion, with roughly a third of humanity among its followers. Centred on the life and teachings of Jesus of Nazareth, it spans many branches, including Catholic, Orthodox, and Protestant churches. Islam is the second largest and one of the fastest growing, built on the teachings revealed to the prophet Muhammad and recorded in the Quran.\n\nThe Indian subcontinent gave rise to several great traditions. Hinduism, among the oldest living religions, encompasses a vast diversity of beliefs and practices centred on concepts such as karma and rebirth. Buddhism, founded on the insights of the Buddha, spread across Asia with its path toward liberation from suffering. Sikhism and Jainism also arose in the region.\n\nJudaism, though smaller in number, holds enormous historical importance as the oldest of the Abrahamic faiths and the shared root of Christianity and Islam. Its scriptures and traditions have influenced law, ethics, and culture far beyond its own community.\n\nAlongside these major faiths are countless indigenous and folk religions, as well as a growing number of people who follow no religion at all. Studying the world's faiths side by side reveals both striking differences and surprising common ground in the questions they ask about meaning, morality, and what lies beyond this life. The GratisAPI catalogue offers datasets on related topics such as mythologies and cultural traditions, a respectful starting point for education, comparison, and exploration.",
      "word_count": 274,
      "reading_time_min": 1,
      "try_api": "gemstones",
      "url": "https://gratisapi.com/api/articles/world-religions-overview"
    },
    {
      "id": "science-ph-scale",
      "title": "The pH Scale",
      "category": "Science",
      "author": "The GratisAPI Team",
      "date": "2024-09-23",
      "tags": [
        "chemistry",
        "acids",
        "ph"
      ],
      "summary": "The pH scale measures how acidic or basic a solution is, running from strong acids at zero to strong bases at fourteen.",
      "body": "Whether a liquid is a mild acid like lemon juice or a caustic base like drain cleaner is captured by a single number: its pH. The pH scale is one of chemistry's most useful measurements, telling us at a glance how acidic or basic, also called alkaline, a water based solution is.\n\nThe scale typically runs from 0 to 14. A pH of 7 is neutral, the value of pure water. Numbers below 7 indicate acidity, and the lower the number the stronger the acid, so stomach acid near 2 and battery acid near 0 sit at the extreme. Numbers above 7 indicate a base, and the higher the number the stronger the base, with household ammonia around 11 and lye near 14. Everyday substances span the range: black coffee is mildly acidic near 5, while baking soda in water is mildly basic near 9.\n\nBehind the number is the concentration of hydrogen ions in the solution. More precisely, pH is defined as the negative logarithm of the hydrogen ion concentration. Because it is a logarithmic scale, each whole step represents a tenfold change. A solution of pH 4 is ten times more acidic than one of pH 5 and a hundred times more acidic than one of pH 6. This is why small differences in pH can have large effects.\n\npH matters far beyond the laboratory. Blood must stay within a narrow range near 7.4, and even slight deviations are dangerous. Soil pH determines which crops will thrive, aquariums must be kept balanced for fish to survive, and swimming pools are constantly adjusted. Chemists measure pH with electronic meters or with indicator dyes such as litmus paper, which turns red in acid and blue in base.",
      "word_count": 287,
      "reading_time_min": 1,
      "try_api": "cocktails",
      "url": "https://gratisapi.com/api/articles/science-ph-scale"
    },
    {
      "id": "reference-number-bases",
      "title": "Number Bases and Binary",
      "category": "Reference",
      "author": "The GratisAPI Team",
      "date": "2024-09-18",
      "tags": [
        "binary",
        "number-bases",
        "cs"
      ],
      "summary": "Number bases are different ways of writing numbers, and computers rely on base two, or binary.",
      "body": "We usually count in tens without thinking about why. The decimal system uses ten digits, zero through nine, and each position in a number counts a power of ten. But ten is not special to mathematics; it is just the number of fingers we happen to have. Numbers can be written in any base, and computers use a different one.\n\nComputers work in binary, or base two, which uses only two digits, zero and one. Each position counts a power of two rather than ten. So the binary number one zero one one means one eight, no fours, one two, and one one, which totals eleven in decimal. Binary suits computers because a circuit can easily represent two states, on and off, but not ten reliably.\n\nBinary numbers grow long quickly, so programmers often use hexadecimal, or base sixteen, as a compact shorthand. Because sixteen is two to the fourth power, each hexadecimal digit stands for exactly four binary digits, making conversion effortless. Hexadecimal uses the digits zero through nine and then the letters A through F for the values ten through fifteen. This is why color codes and memory addresses are often written in hex.\n\nOctal, or base eight, works on the same principle with each digit standing for three binary digits, though it is less common today. Converting between bases is a matter of grouping bits or repeatedly dividing, and once the pattern clicks it becomes routine.\n\nThe key insight is that the number itself does not change between bases, only the way we write it. Eleven objects are eleven objects whether you write the count in decimal, binary, or hex. The base is just notation.\n\nGratisAPI offers a reference at /api/number-bases/index.json that shows values across common bases side by side, which is useful for building converters or checking your own conversions. Understanding bases demystifies a great deal of low level computing, from bit manipulation to memory addresses, and it reveals that our everyday base ten is only one choice among many.",
      "word_count": 334,
      "reading_time_min": 2,
      "try_api": "number-bases",
      "url": "https://gratisapi.com/api/articles/reference-number-bases"
    },
    {
      "id": "freedom-sustainability-of-free-projects",
      "title": "The Sustainability of Free Projects",
      "category": "Philosophy",
      "author": "The GratisAPI Team",
      "date": "2024-08-25",
      "tags": [
        "sustainability",
        "maintenance",
        "funding"
      ],
      "summary": "Free projects face a real challenge in staying alive over time, but low costs, community, and openness offer paths to endurance.",
      "body": "A fair account of free software must face an uncomfortable question: how do projects that charge nothing survive? Maintenance takes time and effort, servers cost money, and the people who do the work have to eat. Sustainability is a genuine challenge, and pretending otherwise helps no one.\n\nThe difficulty is real. Countless free projects are maintained by volunteers in their spare time, and burnout is common. Some critical software the whole world depends on is quietly kept alive by one or two exhausted people. When they stop, the software can stall or decay. The mismatch between how much a project is used and how little its maintainers are supported is a well-known problem.\n\nYet free projects have real advantages in endurance. Openness means the work is never trapped with a single owner; if one maintainer stops, another can pick it up, because the right to fork guarantees continuity. Free software cannot be killed by a bankruptcy or an acquisition in the way proprietary software can.\n\nSeveral funding models have emerged. Some projects thrive on donations and membership. Some are supported by foundations. Some are funded by companies that depend on the software and pay developers to maintain it. Others sell services, support, or hosting around freely licensed code. None is perfect, and the search for stable funding continues, but the ecosystem is not without answers.\n\nDesign choices also affect sustainability. A project with low running costs is far easier to keep alive than one with heavy infrastructure. Static files served from cheap or free hosting, minimal moving parts, and simple architecture reduce the ongoing burden to something a small team or even one person can carry indefinitely.\n\nGratisAPI leans on that last strategy. By staying static, keyless, and simple, it keeps its costs near zero, which makes sustaining it realistic rather than heroic. And because everything is openly licensed, the project can outlive any of us. Sustainability is not guaranteed, but it is designed for.",
      "word_count": 325,
      "reading_time_min": 2,
      "try_api": "birds",
      "url": "https://gratisapi.com/api/articles/freedom-sustainability-of-free-projects"
    },
    {
      "id": "world-us-presidents",
      "title": "The Presidents of the United States",
      "category": "Culture",
      "author": "The GratisAPI Team",
      "date": "2024-08-19",
      "tags": [
        "history",
        "politics"
      ],
      "summary": "From George Washington onward, dozens of presidents have led the United States. This article surveys the office and the people who have held it.",
      "body": "The office of President of the United States is among the most powerful and closely watched positions in the world. Since the nation's founding, a long line of individuals has held the role, each shaping the country and, often, the wider world during their time in office.\n\nGeorge Washington, the commander of the revolutionary army, became the first president in 1789 and set many precedents simply by how he conducted himself, including the tradition of stepping down after two terms. That informal limit held for a century and a half until it was finally written into the Constitution after Franklin Roosevelt won four elections during the Depression and the Second World War.\n\nSeveral presidents are remembered for guiding the nation through defining crises. Abraham Lincoln led the country through its Civil War and moved to end slavery before his assassination. Franklin Roosevelt steered the United States through economic collapse and global conflict. Others are recalled for scandal, such as Richard Nixon, who resigned rather than face impeachment over Watergate.\n\nThe presidency has grown far beyond what the founders imagined. Early presidents governed a young agricultural republic, while modern ones command the world's largest economy and military, and their decisions ripple across the globe. The role blends head of state, head of government, and commander in chief in a single elected figure.\n\nCounting the presidency involves a curious quirk: because one president served two non consecutive terms, the count of presidencies exceeds the number of individual people who have held the office. The GratisAPI US presidents dataset at /api/us-presidents/index.json lists each president with their party, term dates, and number, a clean foundation for building timelines, quizzes, or lessons in American history.",
      "word_count": 280,
      "reading_time_min": 1,
      "try_api": "us-presidents",
      "url": "https://gratisapi.com/api/articles/world-us-presidents"
    },
    {
      "id": "science-mohs-hardness-scale",
      "title": "The Mohs Hardness Scale",
      "category": "Science",
      "author": "The GratisAPI Team",
      "date": "2024-08-19",
      "tags": [
        "geology",
        "minerals",
        "hardness"
      ],
      "summary": "The Mohs scale ranks minerals by scratch resistance from soft talc to hard diamond, a simple field test still used by geologists.",
      "body": "How do you tell one mineral from another when they look similar? One of the oldest and most practical answers is to test how hard they are, and the standard tool for that is the Mohs hardness scale. Devised in 1812 by the German geologist Friedrich Mohs, it ranks minerals by their resistance to being scratched.\n\nThe scale runs from 1 to 10 and is anchored by ten reference minerals. At the soft end sits talc, rated 1, so soft it can be scratched by a fingernail and crumbles into the powder used in talcum. At the hard end is diamond, rated 10, the hardest naturally occurring material known, capable of scratching everything below it and scratched by nothing but another diamond. In between lie gypsum at 2, calcite at 3, fluorite at 4, apatite at 5, feldspar at 6, quartz at 7, topaz at 8, and corundum, the mineral of rubies and sapphires, at 9.\n\nThe test itself is beautifully simple. A harder mineral will scratch a softer one, but not the other way around. Geologists in the field carry a few reference materials, or simply use common objects: a fingernail rates about 2.5, a copper coin around 3, and a steel knife blade or nail near 5.5. If a mystery mineral scratches glass but not a knife, its hardness can be narrowed down quickly.\n\nOne important caveat is that the scale is ordinal, not proportional. The steps are not evenly spaced. Diamond at 10 is many times harder than corundum at 9, a far bigger jump than the gap between talc and gypsum. Still, for quick identification the Mohs scale remains indispensable and is often reported alongside other mineral data in geological reference collections.",
      "word_count": 286,
      "reading_time_min": 1,
      "try_api": "colors",
      "url": "https://gratisapi.com/api/articles/science-mohs-hardness-scale"
    },
    {
      "id": "howto-color-palette-picker",
      "title": "Building a Color-Palette Picker",
      "category": "Tutorials",
      "author": "The GratisAPI Team",
      "date": "2024-08-14",
      "tags": [
        "javascript",
        "colors",
        "ui"
      ],
      "summary": "Use the GratisAPI colors endpoint to build an interactive named-color palette picker.",
      "body": "The colors collection makes an excellent basis for an interactive palette picker. Each record includes a name and its hex, RGB, and HSL values, so you have everything needed to render swatches and copy values on click.\n\nFetch the endpoint at /api/colors/index.json and build a swatch for each record. Set each swatch's background to the color's hex value:\n\nasync function buildPalette() {\n  const res = await fetch(\"https://gratisapi.com/api/colors/index.json\");\n  const data = await res.json();\n  const container = document.getElementById(\"palette\");\n  data.colors.forEach(c => {\n    const swatch = document.createElement(\"div\");\n    swatch.style.background = c.hex;\n    swatch.title = c.name;\n    swatch.addEventListener(\"click\", () => navigator.clipboard.writeText(c.hex));\n    container.appendChild(swatch);\n  });\n}\n\nbuildPalette();\n\nSetting the title attribute gives each swatch a hover tooltip with the color name, and the click handler copies the hex value to the clipboard using the Clipboard API, a small touch that makes the picker genuinely useful for designers.\n\nBecause the full collection loads in one request, adding features costs nothing in extra network calls. You can add a search box that filters the swatches by name in memory, or sort the array by hue using the HSL values each record provides. A toggle could switch the copied value between hex, RGB, and HSL formats, since all three are present in the data.\n\nLay the swatches out with CSS grid or flexbox so they wrap responsively, and add a label that appears on hover showing the name and value together. Handle errors by wrapping the fetch in try/catch and showing a message if the request fails.\n\nThe finished picker is a single static page powered entirely by GratisAPI, with no build step, no keys, and no server. It demonstrates how a well-shaped open dataset can drive a polished, practical tool with only a modest amount of front-end code.",
      "word_count": 286,
      "reading_time_min": 1,
      "try_api": "colors",
      "url": "https://gratisapi.com/api/articles/howto-color-palette-picker"
    },
    {
      "id": "reference-logic-gates",
      "title": "Logic Gates Explained",
      "category": "Reference",
      "author": "The GratisAPI Team",
      "date": "2024-08-05",
      "tags": [
        "logic-gates",
        "hardware",
        "electronics"
      ],
      "summary": "Logic gates are the basic building blocks of digital circuits, combining binary signals into outputs.",
      "body": "Beneath every computer lies an ocean of tiny switches, and logic gates are how those switches are organized to compute. A logic gate takes one or more binary inputs, each either a zero or a one, and produces a binary output according to a fixed rule. From these simple rules, all of digital computation is built.\n\nThe basic gates are few. The AND gate outputs one only when all its inputs are one. The OR gate outputs one when at least one input is one. The NOT gate, which has a single input, simply flips it, turning a zero into a one and back. These three correspond directly to the logical ideas of and, or, and not, which is why the field is called logic.\n\nSeveral other gates are combinations of these. The NAND gate is an AND followed by a NOT, and the NOR gate is an OR followed by a NOT. The XOR, or exclusive or, gate outputs one only when its inputs differ, which makes it central to arithmetic. Remarkably, the NAND gate alone can be wired to reproduce every other gate, which is why it is called universal.\n\nEach gate is fully described by a truth table, a small chart listing the output for every possible combination of inputs. Truth tables make gates precise and let engineers reason about circuits with certainty rather than guesswork.\n\nThe real power comes from combining gates. Wire them together and you can build a circuit that adds two numbers, stores a bit of memory, or chooses between inputs. Stack millions of such circuits and you have a processor. Everything a computer does ultimately reduces to gates switching in patterns.\n\nGratisAPI provides a reference at /api/logic-gates/index.json, where each entry names a gate, gives its symbol, and includes its truth table. It is a handy companion when studying digital electronics or building simple circuits. Understanding gates reveals that the dazzling capability of computers rests on rules a child could follow.",
      "word_count": 328,
      "reading_time_min": 2,
      "try_api": "logic-gates",
      "url": "https://gratisapi.com/api/articles/reference-logic-gates"
    },
    {
      "id": "howto-random-quote-widget",
      "title": "Building a Random-Quote Widget",
      "category": "Tutorials",
      "author": "The GratisAPI Team",
      "date": "2024-07-22",
      "tags": [
        "javascript",
        "widget",
        "quotes"
      ],
      "summary": "Create a small self-contained widget that displays a random quote from the GratisAPI quotes endpoint.",
      "body": "A random-quote widget is a perfect first project with GratisAPI. It needs one endpoint, a little JavaScript, and no backend at all, yet it teaches fetching, parsing, and rendering in one go.\n\nThe quotes collection lives at /api/quotes/index.json and returns an object with a quotes array. Fetch it once, pick a random element, and drop it into the page:\n\nasync function showQuote() {\n  const res = await fetch(\"https://gratisapi.com/api/quotes/index.json\");\n  const data = await res.json();\n  const quotes = data.quotes;\n  const q = quotes[Math.floor(Math.random() * quotes.length)];\n  document.getElementById(\"quote\").textContent = q.text;\n  document.getElementById(\"author\").textContent = q.author;\n}\n\nshowQuote();\n\nThe expression Math.floor(Math.random() * quotes.length) produces a valid random index into the array. Because the whole collection arrives in a single request, you do not need to hit the network again to show another quote. Wire a button to a function that picks a new random element from the array you already have:\n\ndocument.getElementById(\"next\").addEventListener(\"click\", () => {\n  const q = quotes[Math.floor(Math.random() * quotes.length)];\n  // update the DOM here\n});\n\nThis is a real advantage of GratisAPI's full-dataset design. A widget backed by a paginated API would need a fresh request per quote, but here one download powers unlimited shuffles.\n\nTo make it robust, keep the fetched array in a variable at a scope both functions can see, and add a try/catch so a network failure shows a friendly fallback message rather than nothing. For a finishing touch, style the quote with CSS and fade it in on change. The entire widget fits in a single HTML file you can embed anywhere, needs no keys, and costs nothing to run, which is exactly the spirit of a gratis, static API.",
      "word_count": 270,
      "reading_time_min": 1,
      "try_api": "quotes",
      "url": "https://gratisapi.com/api/articles/howto-random-quote-widget"
    },
    {
      "id": "freedom-privacy-no-tracking-api",
      "title": "Privacy and a No-Tracking API",
      "category": "Philosophy",
      "author": "The GratisAPI Team",
      "date": "2024-07-20",
      "tags": [
        "privacy",
        "tracking",
        "surveillance"
      ],
      "summary": "An API that tracks its users turns a simple tool into a surveillance instrument; refusing to track is a deliberate act of respect.",
      "body": "Every request to an API can, in principle, be logged, profiled, and tied back to whoever made it. Over time these records reveal a great deal: what a developer is building, what a researcher is investigating, what questions a person is asking of the world. An API that tracks its users quietly becomes an instrument of surveillance, whatever its stated purpose.\n\nTracking usually rides in on the requirement to identify yourself. API keys, accounts, and tokens exist partly to attach a name to every request. Once requests are tied to identity, they can be aggregated into a profile, retained indefinitely, analyzed, and sometimes sold or handed over. The convenience of a key and the surveillance it enables are two sides of one design.\n\nThe harms are not hypothetical. Usage data can expose confidential projects to competitors, reveal a journalist's sources through the pattern of their queries, or chill the simple curiosity of someone afraid to ask a question that might be recorded. Even when no misuse occurs, the mere knowledge that one is watched changes behavior. Surveillance narrows the range of what people feel free to explore.\n\nThe standard justifications for tracking, abuse prevention and analytics, rarely require identifying individuals. Load can be managed with anonymous, address based rate limiting. Aggregate demand can be understood without building dossiers. The choice to track people is usually a choice, not a necessity.\n\nA no-tracking API takes the opposite stance. It asks for no account, sets no cookies, plants no analytics beacons, and keeps no profile of who you are or what you are doing. The tool does its job and forgets you, as a good tool should. What it does not collect, it cannot leak, sell, or be compelled to reveal.\n\nGratisAPI is designed to be forgettable in exactly this way. There is no key to tie requests to you and nothing that watches what you build. Privacy here is not a policy promise but a property of the design, and that is deliberate.",
      "word_count": 332,
      "reading_time_min": 2,
      "try_api": "planets",
      "url": "https://gratisapi.com/api/articles/freedom-privacy-no-tracking-api"
    },
    {
      "id": "world-roman-numerals",
      "title": "How Roman Numerals Work",
      "category": "Culture",
      "author": "The GratisAPI Team",
      "date": "2024-07-15",
      "tags": [
        "numbers",
        "history"
      ],
      "summary": "Roman numerals build numbers from seven letters using addition and subtraction. This article explains the rules behind this ancient counting system.",
      "body": "Roman numerals still appear on clock faces, in book chapters, and after the names of kings and popes, long after the empire that created them fell. Learning how they work reveals an elegant, if quirky, system of counting with letters.\n\nThe entire system uses just seven symbols: I for one, V for five, X for ten, L for fifty, C for one hundred, D for five hundred, and M for one thousand. Every number is built by combining these letters, generally writing the largest values first and adding them together. So the number thirty is written XXX, and the year 2018 becomes MMXVIII.\n\nThe clever twist is subtraction. Rather than writing four as IIII, the Romans placed a smaller symbol before a larger one to mean subtract, so four becomes IV and nine becomes IX. The same trick gives us forty as XL and ninety as XC. This rule keeps numbers shorter but makes them a little harder to read at first.\n\nThe system has real limitations. There is no symbol for zero, and no simple way to write very large numbers or fractions, which made complicated arithmetic awkward. These shortcomings are a major reason Europe eventually adopted the Hindu Arabic numerals we use today, which handle place value and zero with ease.\n\nYet Roman numerals survive because they look dignified and traditional. They mark the hours on grand clocks, number the Super Bowl, and lend gravity to monuments and film credits. The GratisAPI Roman numerals dataset at /api/roman-numerals/index.json maps values to their numeral forms, a useful reference for building converters, teaching tools, or puzzles that draw on this ancient way of writing numbers.",
      "word_count": 274,
      "reading_time_min": 1,
      "try_api": "roman-numerals",
      "url": "https://gratisapi.com/api/articles/world-roman-numerals"
    },
    {
      "id": "science-beaufort-wind-scale",
      "title": "The Beaufort Wind Scale",
      "category": "Science",
      "author": "The GratisAPI Team",
      "date": "2024-07-14",
      "tags": [
        "meteorology",
        "wind",
        "weather"
      ],
      "summary": "The Beaufort scale rates wind strength from calm to hurricane using the visible effects of wind on the sea and land.",
      "body": "Long before anemometers could precisely measure wind speed, sailors needed a reliable way to describe how strong the wind was blowing. In 1805 a British naval officer named Francis Beaufort devised a scale that did exactly that, and a version of it remains in use around the world today.\n\nThe genius of the Beaufort scale is that it rates wind not by instruments but by its observable effects. The scale runs from 0 to 12. A rating of 0 means calm, with smoke rising straight up and the sea like a mirror. As the numbers climb, the descriptions grow more dramatic. Force 3 is a gentle breeze that extends a light flag, force 6 is a strong breeze that makes umbrellas hard to use and whistles through telegraph wires, and force 8 is a gale that breaks twigs off trees and impedes walking. At the top of the scale, force 12 signifies a hurricane, with devastating winds and a sea whipped into a churning white fury.\n\nBeaufort originally based his scale on how a warship's sails behaved, but it was later adapted to describe the state of the sea, with descriptions of wave height and foam, and eventually extended to effects seen on land, such as swaying trees and flying debris. Each level corresponds to a range of actual wind speeds, allowing modern observers to translate between the descriptive scale and measured values.\n\nThe scale remains valuable precisely because it can be used by anyone, anywhere, with nothing more than careful observation. It gives forecasters, mariners, and coastal communities a shared vocabulary for the wind.\n\nYou can look up each level of the scale, its name, wind speed range, and typical effects through the GratisAPI endpoint at /api/beaufort-scale/index.json.",
      "word_count": 288,
      "reading_time_min": 1,
      "try_api": "beaufort-scale",
      "url": "https://gratisapi.com/api/articles/science-beaufort-wind-scale"
    },
    {
      "id": "howto-excel-power-query",
      "title": "Loading GratisAPI Data into Excel Power Query",
      "category": "Tutorials",
      "author": "The GratisAPI Team",
      "date": "2024-06-17",
      "tags": [
        "excel",
        "power-query",
        "no-code"
      ],
      "summary": "Use Excel's Power Query to import, expand, and refresh GratisAPI JSON collections.",
      "body": "Excel's Power Query, also called Get and Transform, has native support for reading JSON from a web URL, which makes GratisAPI easy to load and refresh without any code.\n\nStart on the Data tab. Choose Get Data, then From Other Sources, then From Web, and paste an endpoint URL such as https://gratisapi.com/api/countries/index.json. Excel fetches the file and opens the Power Query editor, showing the JSON as a record.\n\nThe top-level response is an object with metadata fields and a key holding the list of records. In the editor, drill into that list key, then convert it to a table. Power Query shows a column of record values with an expand button in the header. Click it and select the fields you want, and each becomes its own column. What began as nested JSON is now a clean, flat table ready for the worksheet.\n\nWhen the shape looks right, choose Close and Load to drop the table onto a sheet. The real payoff comes later: because Power Query remembers the query steps, you can click Refresh at any time to re-pull the endpoint and reapply your transformations automatically. You can also set the query to refresh when the workbook opens or on a timer.\n\nEvery transformation is recorded as a step in the applied-steps list, so you can rename columns, change types, filter rows, or sort, and the whole pipeline replays on each refresh. Because GratisAPI endpoints are static files with no authentication, choose anonymous access when Excel prompts for credentials, and the connection just works.\n\nThis workflow turns any GratisAPI collection into a refreshable, analysis-ready Excel table. For business users and analysts who prefer Excel to programming, it is the most direct way to bring open data into familiar tools like PivotTables and charts.",
      "word_count": 294,
      "reading_time_min": 1,
      "try_api": "countries",
      "url": "https://gratisapi.com/api/articles/howto-excel-power-query"
    },
    {
      "id": "reference-sql-keywords",
      "title": "SQL Keywords Overview",
      "category": "Reference",
      "author": "The GratisAPI Team",
      "date": "2024-06-13",
      "tags": [
        "sql",
        "database",
        "query"
      ],
      "summary": "SQL uses a set of keywords to define, query, and modify data stored in relational databases.",
      "body": "SQL, the Structured Query Language, is how programs talk to relational databases. It reads almost like English, and a relatively small set of keywords covers the vast majority of what you will ever write. Grouping those keywords by purpose makes the language easy to learn.\n\nThe most common task is asking questions of the data, and that is the job of SELECT. A query names the columns you want with SELECT and the table they come from with FROM. You narrow the results with WHERE, which filters rows by a condition. You arrange them with ORDER BY and group them for summaries with GROUP BY, often paired with functions that count or total values.\n\nChanging data uses a second group of keywords. INSERT adds new rows, UPDATE modifies existing ones, and DELETE removes them. Each of these is usually paired with a condition so you affect only the intended rows; forgetting a WHERE clause on an update or delete is a classic and painful mistake.\n\nA third group defines the structure of the database itself. CREATE makes a new table or other object, ALTER changes an existing one, and DROP removes it entirely. These commands shape the containers that hold your data rather than the data inside them.\n\nOne of SQL's most powerful features is the JOIN, which combines rows from two tables based on a related column. Joins are what make relational databases relational, letting you connect customers to their orders or books to their authors in a single query. Learning to think in joins is a turning point for anyone using SQL.\n\nGratisAPI offers a reference at /api/sql-keywords/index.json, listing each keyword with its category and a description of what it does. It is a compact study aid while the vocabulary settles into memory. Because SQL is so widespread, across web apps, analytics, and reporting, the effort to learn these keywords pays off across almost every kind of software work.",
      "word_count": 321,
      "reading_time_min": 2,
      "try_api": "sql-keywords",
      "url": "https://gratisapi.com/api/articles/reference-sql-keywords"
    },
    {
      "id": "freedom-reproducibility-and-open-data",
      "title": "Reproducibility and Open Data",
      "category": "Philosophy",
      "author": "The GratisAPI Team",
      "date": "2024-06-11",
      "tags": [
        "reproducibility",
        "science",
        "open-data"
      ],
      "summary": "Reproducibility is a cornerstone of science, and open data is essential to letting others verify and build on published results.",
      "body": "Reproducibility is a foundational principle of science: a result is trustworthy only if others, following the same methods, can obtain the same outcome. A finding no one else can reproduce is not yet knowledge but a claim awaiting confirmation. Open data is increasingly essential to making reproducibility possible.\n\nModern research runs on data. Studies analyze large datasets with complex software, and the conclusions depend entirely on both the data and the exact processing applied to it. If the underlying data is hidden, other researchers cannot check whether the analysis was done correctly, whether the results hold, or whether errors crept in. They are asked to take the conclusions on faith.\n\nScience has confronted a so-called replication crisis, in which many published findings across several fields proved difficult or impossible to reproduce. The causes are varied, but a recurring theme is the unavailability of data and code. When materials are closed, mistakes and even misconduct can hide, and honest work cannot be independently confirmed.\n\nOpen data addresses this directly. When researchers publish their datasets alongside their papers, others can rerun the analysis, test alternative methods, catch errors, and extend the work in new directions. Reproducibility shifts from a hopeful assumption to something anyone can actually attempt. Open code matters for the same reason, since the processing steps are part of the method.\n\nThere are legitimate limits. Some data cannot be shared because it identifies individuals or carries genuine privacy risks, and responsible openness respects those boundaries. But a great deal of research data has no such constraint and is closed only by habit or convenience.\n\nGratisAPI supports this culture in a modest way. By providing data in open, stable, machine readable form under a free license, we make it easier for anyone to reproduce an analysis that used our data, and to verify rather than trust. Reproducibility depends on access, and access is what an open API is for.",
      "word_count": 318,
      "reading_time_min": 2,
      "try_api": "quotes",
      "url": "https://gratisapi.com/api/articles/freedom-reproducibility-and-open-data"
    },
    {
      "id": "world-morse-code-history",
      "title": "A Short History of Morse Code",
      "category": "Culture",
      "author": "The GratisAPI Team",
      "date": "2024-06-10",
      "tags": [
        "communication",
        "history"
      ],
      "summary": "Morse code turned language into dots and dashes and connected the world by telegraph. This article traces its invention and lasting legacy.",
      "body": "Before the telephone and the internet, the fastest way to send a message across a continent was to tap it out in Morse code. This simple system of dots and dashes helped shrink the world in the nineteenth century and remains in limited use today.\n\nMorse code was developed in the 1830s and 1840s alongside the electric telegraph, with Samuel Morse and his collaborators among its key figures. The idea was elegant: represent each letter and number with a unique sequence of short signals, called dots, and long signals, called dashes. A skilled operator could send and receive these signals with remarkable speed.\n\nThe design was cleverly efficient. The most common letters were given the shortest codes, so the letter E is a single dot and T is a single dash, while rarer letters received longer sequences. This kept messages as brief as possible, an early example of the kind of thinking that later shaped data compression.\n\nFor over a century Morse code was the backbone of long distance communication, carried first along telegraph wires and later through the air by radio. Its most famous sequence is the distress signal SOS, three dots, three dashes, three dots, chosen because it is simple and unmistakable. Ships in danger tapped it out to summon help across the empty ocean.\n\nThough professional maritime use of Morse ended in the 1990s, the code has not died. Amateur radio operators still use it, it can be sent by light or sound when other methods fail, and it can even be tapped out by people unable to speak. The GratisAPI Morse code dataset at /api/morse-code/index.json lists each character with its dot and dash pattern, a handy reference for building translators, learning tools, or puzzles.",
      "word_count": 288,
      "reading_time_min": 1,
      "try_api": "morse-code",
      "url": "https://gratisapi.com/api/articles/world-morse-code-history"
    },
    {
      "id": "science-essential-vitamins",
      "title": "The Essential Vitamins",
      "category": "Science",
      "author": "The GratisAPI Team",
      "date": "2024-06-10",
      "tags": [
        "biology",
        "nutrition",
        "vitamins"
      ],
      "summary": "Vitamins are essential nutrients the body needs in small amounts, each playing a specific role in keeping us healthy.",
      "body": "Vitamins are a group of nutrients that the human body needs in only tiny quantities, yet cannot survive without. Unlike proteins, fats, and carbohydrates, which supply energy and building material in bulk, vitamins act as helpers that keep countless biochemical reactions running. Because the body generally cannot make them in sufficient amounts, we must obtain them from food.\n\nThere are thirteen recognized vitamins, and they fall into two broad categories based on how they dissolve. The fat soluble vitamins, A, D, E, and K, dissolve in fats and can be stored in the body's fatty tissue and liver for later use. The water soluble vitamins, which include vitamin C and the eight B vitamins, dissolve in water and are mostly not stored, so they need to be replenished regularly, and any excess is flushed out in urine.\n\nEach vitamin has its own job. Vitamin A supports vision and immune function. The B vitamins help convert food into energy and build red blood cells and DNA. Vitamin C aids the body in making collagen and acts as an antioxidant, and a severe lack of it causes scurvy, the disease that once plagued sailors on long voyages. Vitamin D helps the body absorb calcium for strong bones, and our skin can make it when exposed to sunlight. Vitamin K is essential for blood to clot properly.\n\nHistorically, the discovery of vitamins solved the mystery of deficiency diseases like scurvy, rickets, and beriberi, which turned out to be caused not by infection but by the absence of specific nutrients. A varied, balanced diet usually supplies all thirteen in the right amounts.\n\nYou can explore each vitamin, its functions, and its food sources through the GratisAPI endpoint at /api/vitamins/index.json.",
      "word_count": 285,
      "reading_time_min": 1,
      "try_api": "vitamins",
      "url": "https://gratisapi.com/api/articles/science-essential-vitamins"
    },
    {
      "id": "science-blood-type-compatibility",
      "title": "Blood Type Compatibility",
      "category": "Science",
      "author": "The GratisAPI Team",
      "date": "2024-05-21",
      "tags": [
        "biology",
        "medicine",
        "blood-types"
      ],
      "summary": "Blood types determine who can safely donate to whom, a matching system that is a matter of life and death in transfusions.",
      "body": "Not all blood is alike, and mixing the wrong types can be fatal. This is why blood typing is one of the most important routine tests in medicine. The system that matters most is the ABO group, which sorts blood into four types: A, B, AB, and O.\n\nThe types are defined by molecules called antigens on the surface of red blood cells. Type A blood carries the A antigen, type B carries the B antigen, type AB carries both, and type O carries neither. Crucially, your blood plasma contains antibodies against whichever antigens you lack. A person with type A blood, for example, has antibodies that attack type B cells. If incompatible blood is transfused, these antibodies cause the donor cells to clump together, which can be deadly.\n\nThis leads to the famous compatibility rules. Type O negative blood has no ABO antigens and is called the universal donor because it can be given to almost anyone in an emergency. Type AB positive blood, carrying every antigen and no attacking antibodies, is the universal recipient, able to receive from any group.\n\nLayered on top of ABO is the Rhesus, or Rh, factor, another antigen that a person either has, making them positive, or lacks, making them negative. This is the plus or minus you see after your blood type. The Rh factor matters especially in pregnancy, where a mismatch between mother and baby can cause serious complications that doctors now prevent with a simple injection.\n\nBecause of these rules, blood banks must carefully match donors and recipients, and certain types are always in high demand. You can look up the antigens, antibodies, and compatibility of each blood type through the GratisAPI endpoint at /api/blood-types/index.json.",
      "word_count": 285,
      "reading_time_min": 1,
      "try_api": "blood-types",
      "url": "https://gratisapi.com/api/articles/science-blood-type-compatibility"
    },
    {
      "id": "howto-google-sheets",
      "title": "Pulling GratisAPI Data into Google Sheets",
      "category": "Tutorials",
      "author": "The GratisAPI Team",
      "date": "2024-05-20",
      "tags": [
        "google-sheets",
        "apps-script",
        "no-code"
      ],
      "summary": "Import GratisAPI collections into a spreadsheet using IMPORTDATA or a short Apps Script function.",
      "body": "You do not need to be a programmer to use GratisAPI. Google Sheets can pull the data in with a built-in formula or a small script, turning any endpoint into a live spreadsheet.\n\nFor the simplest cases, the IMPORTDATA function fetches a URL directly into cells. However, IMPORTDATA expects CSV or plain tabular text, and GratisAPI serves JSON, so it works best with a helper that returns flattened data. The most reliable approach for JSON is a short Apps Script custom function.\n\nOpen Extensions, then Apps Script, and add a function that fetches an endpoint and returns a two-dimensional array, which Sheets spreads across cells:\n\nfunction GRATIS(url, key) {\n  const res = UrlFetchApp.fetch(url);\n  const data = JSON.parse(res.getContentText());\n  const rows = data[key];\n  const headers = Object.keys(rows[0]);\n  const out = [headers];\n  rows.forEach(r => out.push(headers.map(h => r[h])));\n  return out;\n}\n\nBack in the sheet, call it like a formula: =GRATIS(\"https://gratisapi.com/api/colors/index.json\", \"colors\"). The first argument is the endpoint URL and the second is the key holding the record array. The function returns a header row followed by one row per record, and Sheets fills the surrounding cells automatically.\n\nUrlFetchApp handles the network request inside Google's infrastructure, so there are no keys to configure and no CORS issues to worry about. Because GratisAPI endpoints are static and keyless, the fetch just works.\n\nOnce the data is in the grid, all of Sheets is available: sort, filter, build pivot tables, or chart the results. If you want the sheet to refresh, re-open it or use a time-driven trigger in Apps Script to re-run the fetch on a schedule. This makes GratisAPI a friendly data source for analysts and non-developers who live in spreadsheets rather than code editors.",
      "word_count": 281,
      "reading_time_min": 1,
      "try_api": "colors",
      "url": "https://gratisapi.com/api/articles/howto-google-sheets"
    },
    {
      "id": "freedom-the-right-to-fork",
      "title": "The Right to Fork",
      "category": "Philosophy",
      "author": "The GratisAPI Team",
      "date": "2024-05-16",
      "tags": [
        "forking",
        "governance",
        "freedom"
      ],
      "summary": "The freedom to fork a project is the ultimate guarantee in free software, keeping maintainers accountable and users independent.",
      "body": "To fork a project is to take its code and continue developing it independently, on your own terms. In free software this is not a hostile act but a fundamental right, guaranteed by the freedoms to modify and redistribute. The right to fork is quietly one of the most powerful features of the whole system.\n\nIts power lies in what it prevents. Because anyone can fork a free project, no maintainer holds absolute power over its users. If a project's leaders make decisions the community rejects, add unwanted restrictions, sell out, or simply abandon the work, the community can take the code and carry on. The threat of forking keeps maintainers accountable even when it is never exercised.\n\nHistory offers real examples. When the office suite OpenOffice stalled, the community forked it into LibreOffice, which flourished. When concerns arose about the stewardship of certain projects, forks preserved a free path forward. These were not failures of the system but the system working as designed, providing an exit when voice was not enough.\n\nForking also protects against death. Proprietary software dies when its owner stops supporting it, and users are simply stranded. Free software cannot truly die as long as anyone cares enough to keep a fork alive. The code outlives any single company or maintainer.\n\nThere are costs. Forks can fragment a community, split limited developer attention, and confuse users. A healthy ecosystem does not fork casually, and the mere ability to fork often makes actual forks unnecessary by encouraging compromise. The right matters more as a backstop than as a routine.\n\nGratisAPI is fully forkable. Everything, the data pipeline, the code, and the content, is available under the GPL. If we ever go astray, you do not have to persuade us to change course. You can take the whole thing and build the version you would rather have. That standing exit is what makes our promises trustworthy.",
      "word_count": 318,
      "reading_time_min": 2,
      "try_api": "planets",
      "url": "https://gratisapi.com/api/articles/freedom-the-right-to-fork"
    },
    {
      "id": "reference-git-commands",
      "title": "A Git Commands Cheat Sheet",
      "category": "Reference",
      "author": "The GratisAPI Team",
      "date": "2024-05-07",
      "tags": [
        "git",
        "version-control",
        "tools"
      ],
      "summary": "A tour of the essential git commands every developer uses to track and share code changes.",
      "body": "Git is the version control system that most of the software world runs on. It records the history of a project, lets many people work together without overwriting each other, and makes it safe to experiment because you can always return to an earlier state. A modest set of commands covers most daily work.\n\nEverything begins with a repository. The command that clones an existing project copies it to your machine along with its full history, while the command that initializes a repository turns a plain folder into a tracked one. From there, your work revolves around commits, which are saved snapshots of the project.\n\nMaking a commit takes two steps. First you stage the changes you want to record, selecting which edits belong together. Then you commit the staged changes with a message describing them. This two stage process lets you craft tidy, meaningful history rather than dumping every change at once. The status command shows what is staged, changed, or untracked, and the diff command shows exactly what you altered.\n\nBranches are where git shines. A branch is an independent line of development, so you can build a feature without disturbing the main code. You create a branch, switch to it, do your work, and later merge it back. If two branches change the same lines, git reports a conflict for you to resolve by hand, which sounds scary but is routine.\n\nSharing happens through remotes. The command that pushes sends your commits to a shared server, while the command that pulls fetches and integrates others' work. The log command lets you review the history that results.\n\nGratisAPI provides a reference at /api/git-commands/index.json, where each entry names a command and describes what it does. It makes a handy pocket guide while you build the habits. Git rewards a little study; once the core commands feel natural, you gain a safety net that makes bold changes and smooth collaboration possible.",
      "word_count": 321,
      "reading_time_min": 2,
      "try_api": "git-commands",
      "url": "https://gratisapi.com/api/articles/reference-git-commands"
    },
    {
      "id": "world-nato-phonetic-alphabet",
      "title": "The NATO Phonetic Alphabet",
      "category": "Culture",
      "author": "The GratisAPI Team",
      "date": "2024-05-06",
      "tags": [
        "communication",
        "alphabet"
      ],
      "summary": "Alfa, Bravo, Charlie: the NATO phonetic alphabet spells out letters clearly over noisy radio links. This article explains how and why it was created.",
      "body": "When a pilot reads a call sign over a crackling radio, the difference between the letters B and D can be impossible to hear. The NATO phonetic alphabet solves this by replacing each letter with a distinct word, so that even a garbled transmission comes through clearly.\n\nThe system assigns a code word to every letter: Alfa, Bravo, Charlie, Delta, Echo, and so on through to X-ray, Yankee, and Zulu. The words were carefully chosen and tested so that they sound different from one another even amid heavy static and across speakers of many languages. Alfa and Juliett are spelled unusually to help non English speakers pronounce them correctly.\n\nDespite its name, the alphabet is not just a military tool. It was adopted by the International Civil Aviation Organization in the 1950s and is used worldwide in aviation, shipping, emergency services, and everyday customer support calls, whenever someone needs to spell something out without any risk of confusion.\n\nThe alphabet emerged from decades of trial and error. Earlier spelling alphabets varied from country to country, causing dangerous misunderstandings between allies. After extensive research into which words survived poor radio conditions best, the current version was standardised so that everyone, everywhere, would use the same set.\n\nIts usefulness extends far beyond radios. Anyone reading out a serial number, a booking reference, or a password over the phone benefits from a shared, unambiguous way to name letters. The GratisAPI NATO alphabet dataset at /api/nato-alphabet/index.json lists each letter with its code word, a simple and reliable reference for building communication tools, training aids, or games that put the alphabet to work.",
      "word_count": 268,
      "reading_time_min": 1,
      "try_api": "nato-alphabet",
      "url": "https://gratisapi.com/api/articles/world-nato-phonetic-alphabet"
    },
    {
      "id": "science-sharks-older-than-trees",
      "title": "Sharks: Older Than Trees",
      "category": "Science",
      "author": "The GratisAPI Team",
      "date": "2024-04-15",
      "tags": [
        "biology",
        "sharks",
        "evolution"
      ],
      "summary": "Sharks have patrolled the oceans for over 400 million years, predating trees, dinosaurs, and even the rings of Saturn.",
      "body": "Sharks are among the most ancient animals still living today. Their lineage stretches back more than 400 million years, which means sharks were already swimming the seas long before the first trees took root on land. They predate the dinosaurs by roughly 200 million years and have survived every one of Earth's major mass extinctions.\n\nWhat makes sharks so distinctive is their skeleton. Unlike the bony fish that dominate the oceans, sharks belong to a group called cartilaginous fish, whose skeletons are made of cartilage, the same flexible tissue found in the human nose and ears. Cartilage is lighter and more flexible than bone, helping sharks stay buoyant and maneuverable without the heavy skeleton other fish carry. Their skin is covered in tiny tooth like scales that reduce drag as they glide through the water.\n\nSharks are superbly equipped predators. Many species continuously grow and shed teeth throughout their lives, replacing lost ones from rows waiting behind the front teeth, so a single shark may go through thousands of teeth. They possess an extraordinary sense of smell and can detect the faint electric fields produced by the muscles of hidden prey through special organs in their snouts.\n\nDespite their fearsome reputation, the more than 500 known species of sharks are wonderfully varied. They range from the dwarf lantern shark small enough to hold in one hand to the whale shark, the largest fish in the world, which is a gentle giant that filters tiny plankton from the water. Most sharks pose no threat to people at all.\n\nSadly, many shark populations are now in decline due to overfishing. You can explore different shark species and their characteristics through the GratisAPI endpoint at /api/sharks/index.json.",
      "word_count": 283,
      "reading_time_min": 1,
      "try_api": "sharks",
      "url": "https://gratisapi.com/api/articles/science-sharks-older-than-trees"
    },
    {
      "id": "world-tarot-major-arcana",
      "title": "The Major Arcana of Tarot",
      "category": "Culture",
      "author": "The GratisAPI Team",
      "date": "2024-04-12",
      "tags": [
        "tarot",
        "symbolism"
      ],
      "summary": "The Major Arcana are twenty-two symbolic cards at the heart of the tarot deck. This article introduces their imagery and interpretation.",
      "body": "A tarot deck is divided into two parts, and the twenty-two cards of the Major Arcana are its dramatic core. Where the Minor Arcana resemble ordinary playing cards, the Major Arcana are rich symbolic images that many readers treat as the most meaningful cards in a spread.\n\nThe sequence runs from the Fool, numbered zero, through cards such as the Magician, the High Priestess, the Empress, and the Emperor, on to the Wheel of Fortune, Death, the Tower, the Star, the Sun, and finally the World. Read in order, they are often described as the Fool's Journey, an allegory of a soul passing through the great experiences and lessons of life.\n\nEach card carries layers of meaning drawn from mythology, astrology, and medieval symbolism. Some, like the Sun and the Star, are generally seen as hopeful. Others, like the Tower and Death, look ominous but are usually interpreted more subtly. Death, for instance, is commonly read as transformation and endings that make way for new beginnings rather than literal demise.\n\nTarot began in fifteenth century Europe as a card game, and only centuries later did it become associated with divination and self reflection. Today people use the cards in many ways, from fortune telling to meditation to creative brainstorming, without necessarily believing they predict the future.\n\nThe imagery has also become a wellspring for artists, who reinterpret the traditional cards in countless visual styles. The GratisAPI tarot Major Arcana dataset at /api/tarot-major-arcana/index.json lists each card with its number, name, and traditional meanings, a clean reference for building reading apps, study tools, or creative projects inspired by these enduring images.",
      "word_count": 269,
      "reading_time_min": 1,
      "try_api": "tarot-major-arcana",
      "url": "https://gratisapi.com/api/articles/world-tarot-major-arcana"
    },
    {
      "id": "reference-design-patterns",
      "title": "An Overview of Design Patterns",
      "category": "Reference",
      "author": "The GratisAPI Team",
      "date": "2024-04-11",
      "tags": [
        "design-patterns",
        "programming",
        "architecture"
      ],
      "summary": "Design patterns are reusable solutions to recurring problems in object oriented software design.",
      "body": "As programmers built larger systems, they noticed the same design problems appearing over and over. Design patterns are the collected, named solutions to those recurring problems. A pattern is not code you copy but a proven approach you adapt, and having names for these approaches gives teams a shared vocabulary.\n\nThe classic patterns are usually grouped into three families. Creational patterns deal with how objects are made. The singleton ensures a class has only one instance, the factory hides the details of which concrete class to build, and the builder assembles a complex object step by step. These patterns keep object creation flexible and centralized.\n\nStructural patterns deal with how objects are composed into larger structures. The adapter lets two incompatible interfaces work together by translating between them. The decorator wraps an object to add behavior without changing its class. The facade offers a simple front door to a complicated subsystem. These patterns help you assemble parts cleanly.\n\nBehavioral patterns deal with how objects communicate. The observer lets many objects react automatically when one changes state, which underlies most event systems. The strategy lets you swap an algorithm at run time by treating it as an interchangeable object. The iterator provides a standard way to walk through a collection without exposing its internals.\n\nPatterns are valuable because they capture hard won experience. When you recognize that a problem fits the observer pattern, you inherit a solution that many others have refined and tested. Patterns also make code easier to discuss, since a single word can convey a whole design idea to a teammate.\n\nA word of caution accompanies them: patterns are tools, not goals. Forcing a pattern where a simple approach would do adds needless complexity. The skill is recognizing when a problem genuinely matches a pattern.\n\nGratisAPI offers a reference at /api/design-patterns/index.json, listing each pattern with its category and a short description. It serves as a quick reminder of the catalog, a useful companion when you sense a familiar problem and want to recall the pattern that fits it.",
      "word_count": 340,
      "reading_time_min": 2,
      "try_api": "design-patterns",
      "url": "https://gratisapi.com/api/articles/reference-design-patterns"
    },
    {
      "id": "howto-swift",
      "title": "Consuming GratisAPI in Swift",
      "category": "Tutorials",
      "author": "The GratisAPI Team",
      "date": "2024-04-08",
      "tags": [
        "swift",
        "urlsession",
        "codable"
      ],
      "summary": "Fetch GratisAPI data in Swift with URLSession and decode it using Codable structs.",
      "body": "Swift's URLSession and the Codable protocol make consuming GratisAPI clean and type-safe, which is ideal for iOS, macOS, and server-side Swift projects. Because the endpoints are static JSON files with no keys, the networking code is minimal.\n\nStart by defining Codable structs that mirror the response. Swift's JSONDecoder maps JSON keys to your properties automatically when the names match:\n\nstruct Response: Codable {\n    let count: Int\n    let quotes: [Quote]\n}\n\nstruct Quote: Codable {\n    let text: String\n    let author: String\n}\n\nThen fetch and decode using the async URLSession API:\n\nlet url = URL(string: \"https://gratisapi.com/api/quotes/index.json\")!\nlet (data, _) = try await URLSession.shared.data(from: url)\nlet result = try JSONDecoder().decode(Response.self, from: data)\nprint(\"Loaded \\(result.count) quotes\")\n\nThe data(from:) method returns the body and a response object; you can inspect the response as an HTTPURLResponse to check the status code before trusting the payload. The try keyword surfaces both network and decoding errors, so wrap the call in a do/catch to handle them gracefully.\n\nIf JSON keys use a different style than your Swift properties, set the decoder's keyDecodingStrategy or provide CodingKeys. Mark optional fields with a question mark so a missing value does not cause the decode to throw.\n\nBecause GratisAPI returns entire collections, one request gives you an array to drive a SwiftUI list or a table view. In SwiftUI you might call this loader from a task modifier and store the result in an observable model. With no authentication and no rate limits, GratisAPI integrates smoothly into the Swift concurrency model, giving you strongly typed open data with very little code and full compile-time safety about its structure.",
      "word_count": 267,
      "reading_time_min": 1,
      "try_api": "quotes",
      "url": "https://gratisapi.com/api/articles/howto-swift"
    },
    {
      "id": "freedom-data-as-public-good",
      "title": "Data as a Public Good",
      "category": "Philosophy",
      "author": "The GratisAPI Team",
      "date": "2024-04-02",
      "tags": [
        "public-good",
        "data",
        "economics"
      ],
      "summary": "Data has the economic character of a public good, which makes a strong case for providing certain datasets freely to everyone.",
      "body": "Economists use the term public good for something with two particular properties: it is non-rivalrous, meaning one person's use does not diminish another's, and it is non-excludable, meaning it is difficult to prevent people from using it. Classic examples include clean air, national defense, and lighthouses. Much data fits this description remarkably well.\n\nData is strikingly non-rivalrous. If you download a dataset, there is exactly as much left for everyone else. Unlike a loaf of bread or a barrel of oil, information is not consumed by use. It can be copied endlessly at almost no cost, which means the natural abundance of data is limited only by the artificial scarcity we choose to impose on it.\n\nThis has an important consequence. When a resource is non-rivalrous, restricting access does not conserve anything; it simply excludes people who could have benefited at no cost to anyone else. Charging for access to abundant data, or locking it behind keys, creates scarcity where none needs to exist. The exclusion is a choice, not a necessity.\n\nMarkets tend to underproduce public goods, because it is hard to profit from something everyone can freely use. This is a standard argument for why public institutions fund lighthouses, basic research, and, one can argue, foundational datasets. Some data is too broadly useful to be left entirely to private incentives.\n\nNot all data is a public good. Personal data raises real questions of privacy and consent, and some datasets are genuinely costly to gather and maintain. Treating data as a public good does not mean all information should be free, but that broadly useful, non-personal data has an economic character that favors openness.\n\nGratisAPI treats its data accordingly. Because serving one more request costs almost nothing and deprives no one, we see no reason to ration access. Data that behaves like a public good should be offered like one.",
      "word_count": 311,
      "reading_time_min": 2,
      "try_api": "animals",
      "url": "https://gratisapi.com/api/articles/freedom-data-as-public-good"
    },
    {
      "id": "howto-java",
      "title": "Consuming GratisAPI in Java",
      "category": "Tutorials",
      "author": "The GratisAPI Team",
      "date": "2024-03-12",
      "tags": [
        "java",
        "http-client",
        "json"
      ],
      "summary": "Use Java's built-in HttpClient to fetch GratisAPI endpoints and parse the JSON response.",
      "body": "Modern Java, from version 11 onward, includes a capable HttpClient in the java.net.http package, so fetching GratisAPI needs no external HTTP library. You do still need a JSON parser, and popular choices include Jackson and Gson.\n\nFirst make the request. Build a client, construct a request pointing at the endpoint, and send it, asking for the body as a String:\n\nimport java.net.http.*;\nimport java.net.URI;\n\nHttpClient client = HttpClient.newHttpClient();\nHttpRequest request = HttpRequest.newBuilder()\n    .uri(URI.create(\"https://gratisapi.com/api/quotes/index.json\"))\n    .build();\nHttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());\nSystem.out.println(response.statusCode());\n\nWith the JSON text in hand, parse it. Using Jackson's ObjectMapper you can bind the response to a plain Java class whose fields mirror the JSON keys, or read it into a generic tree of JsonNode objects when you only need a few values. Gson works similarly through its fromJson method and mapping classes.\n\nCheck response.statusCode() before parsing so a 404 does not lead to a confusing parse error. For asynchronous work, HttpClient also offers sendAsync, which returns a CompletableFuture you can chain, letting you fetch several endpoints without blocking a thread each.\n\nBecause GratisAPI serves complete collections, a single request delivers the full dataset, which you then iterate with ordinary Java loops or streams. The Streams API is a natural fit for filtering and transforming the records. Since the endpoints require no authentication and impose no rate limits, the only setup is choosing a JSON library. Once that is in place, GratisAPI becomes a clean, keyless data source you can wire into anything from a command-line tool to a Spring service.",
      "word_count": 252,
      "reading_time_min": 1,
      "try_api": "quotes",
      "url": "https://gratisapi.com/api/articles/howto-java"
    },
    {
      "id": "world-chinese-zodiac",
      "title": "The Chinese Zodiac",
      "category": "Culture",
      "author": "The GratisAPI Team",
      "date": "2024-03-08",
      "tags": [
        "zodiac",
        "china"
      ],
      "summary": "The Chinese zodiac assigns each year one of twelve animals in a repeating cycle. This article explains the cycle and the legend behind it.",
      "body": "The Chinese zodiac works very differently from its Western counterpart. Instead of dividing a single year into twelve signs, it assigns each whole year one of twelve animals, which repeat in a fixed cycle. Your sign depends on the year you were born rather than the month.\n\nThe twelve animals are the rat, ox, tiger, rabbit, dragon, snake, horse, goat, monkey, rooster, dog, and pig. A popular legend explains their order through a great race organised by the Jade Emperor. The clever rat rode on the ox and jumped ahead at the finish to claim first place, while the pig, who paused to eat and nap, came last.\n\nEach animal is believed to lend its qualities to people born in its year. Those born in the year of the dragon, the only mythical creature in the group, are thought to be ambitious and charismatic, which makes dragon years especially popular for having children. The system is deeply woven into East Asian culture and features prominently in Lunar New Year celebrations.\n\nThe full picture is more intricate still. The twelve animals combine with five elements, wood, fire, earth, metal, and water, producing a grand cycle of sixty years before any exact combination repeats. Traditional astrologers also consider the animal of your birth month, day, and hour, building a detailed personal profile.\n\nBecause the cycle follows the lunar calendar, the animal years do not align neatly with the Western calendar, beginning instead with the Lunar New Year in late winter. The GratisAPI Chinese zodiac dataset at /api/chinese-zodiac/index.json lists each animal with its associated traits and years, a handy reference for building New Year greetings, quizzes, or apps that celebrate this ancient cycle.",
      "word_count": 280,
      "reading_time_min": 1,
      "try_api": "chinese-zodiac",
      "url": "https://gratisapi.com/api/articles/world-chinese-zodiac"
    },
    {
      "id": "science-age-of-the-dinosaurs",
      "title": "The Age of the Dinosaurs",
      "category": "Science",
      "author": "The GratisAPI Team",
      "date": "2024-03-08",
      "tags": [
        "paleontology",
        "dinosaurs",
        "prehistoric"
      ],
      "summary": "Dinosaurs dominated the land for over 160 million years across the Mesozoic Era before a catastrophic extinction ended their reign.",
      "body": "For a span of time almost impossible to grasp, dinosaurs ruled the Earth. Their reign lasted more than 160 million years, dwarfing the few million years that humans and our ancestors have existed. This great era is called the Mesozoic, and geologists divide it into three periods: the Triassic, the Jurassic, and the Cretaceous.\n\nDinosaurs first appeared during the Triassic, around 230 million years ago, when the continents were joined into a single landmass called Pangaea. Early dinosaurs were relatively small, but they gradually rose to dominance. In the Jurassic that followed, they grew to spectacular sizes. The long necked sauropods such as Brachiosaurus and Diplodocus became the largest animals ever to walk on land, browsing treetops on pillar like legs.\n\nThe Cretaceous period brought some of the most famous dinosaurs of all. Tyrannosaurus rex, one of the largest land predators known, prowled North America near the very end of the age, while the three horned Triceratops and the armored Ankylosaurus defended themselves against such hunters. Duck billed dinosaurs roamed in vast herds.\n\nThen it ended abruptly. About 66 million years ago a massive asteroid struck what is now Mexico, unleashing wildfires, tsunamis, and a global winter as dust blocked the Sun. This catastrophe wiped out the non bird dinosaurs along with roughly three quarters of all species on Earth. Yet the dinosaurs did not vanish entirely. Birds are the living descendants of small feathered dinosaurs, which means the lineage survives all around us today.\n\nModern research shows many dinosaurs were active, warm blooded, and often feathered, a far cry from the sluggish reptiles once imagined. You can browse dinosaur species and their details through the GratisAPI endpoint at /api/dinosaurs/index.json.",
      "word_count": 280,
      "reading_time_min": 1,
      "try_api": "dinosaurs",
      "url": "https://gratisapi.com/api/articles/science-age-of-the-dinosaurs"
    },
    {
      "id": "freedom-api-keys-tax-on-curiosity",
      "title": "Why API Keys Are a Tax on Curiosity",
      "category": "Philosophy",
      "author": "The GratisAPI Team",
      "date": "2024-03-08",
      "tags": [
        "api-keys",
        "friction",
        "access"
      ],
      "summary": "Mandatory API keys add friction that discourages casual exploration, quietly taxing the curiosity that drives learning and experimentation.",
      "body": "Requiring an API key before anyone can make a single request is so common that it is rarely questioned. Yet mandatory keys impose a quiet cost on the very thing that makes technology vibrant: casual, low-stakes curiosity. In that sense a key requirement functions as a tax on exploration.\n\nConsider the path a key demands. To try an API, you must find the signup page, create an account, verify an email, perhaps confirm a phone number, accept terms of service, generate a key, and store it securely. Only then can you make the request you wanted to make ten minutes ago. Each step is small, but together they turn a moment of curiosity into a chore.\n\nMost curiosity does not survive that friction. A student wondering how an API responds, a developer testing an idea at midnight, a teacher building a quick classroom example, a person simply poking at how something works, all of them are more likely to give up than to complete a registration flow. The ideas that die at the signup wall are invisible, but they are real.\n\nKeys exist for reasons, of course. They enable rate limiting, usage tracking, abuse prevention, and billing. For a commercial service metering paid access, keys make sense. But for open, public data, the justification is weaker, and the tracking that keys enable is often a cost to users rather than a benefit.\n\nThere are gentler ways to protect a service. Anonymous rate limiting by address, static hosting that scales cheaply, and caching can handle load without demanding identity from every visitor. A public well does not ask for your name before you drink.\n\nGratisAPI requires no keys at all. You can make your first request immediately, with a single line, before curiosity has a chance to cool. Removing that tax is a deliberate design choice, because the experiments people never start are the most expensive ones of all.",
      "word_count": 318,
      "reading_time_min": 2,
      "try_api": "gemstones",
      "url": "https://gratisapi.com/api/articles/freedom-api-keys-tax-on-curiosity"
    },
    {
      "id": "reference-sorting-algorithms",
      "title": "Sorting Algorithms Compared",
      "category": "Reference",
      "author": "The GratisAPI Team",
      "date": "2024-03-04",
      "tags": [
        "sorting",
        "algorithms",
        "cs"
      ],
      "summary": "Sorting algorithms arrange data in order, and they differ widely in speed, memory, and simplicity.",
      "body": "Sorting is one of the most studied problems in computing, because putting data in order makes so many other tasks easier. Many algorithms solve it, and comparing them is a classic way to learn how algorithm design trades simplicity against speed.\n\nThe simplest algorithms are easy to understand but slow. Bubble sort repeatedly steps through the list, swapping neighbors that are out of order, until no swaps remain. Selection sort finds the smallest remaining item and moves it into place each pass. Insertion sort builds the sorted list one item at a time, sliding each new value into position. All three take quadratic time, meaning their work grows with the square of the input, so they struggle on large lists but are fine for small ones.\n\nThe faster algorithms use a divide and conquer strategy. Merge sort splits the list in half, sorts each half, and merges the results, guaranteeing linearithmic time in every case but needing extra memory. Quicksort partitions the list around a chosen pivot and sorts the parts; it is usually very fast and works in place, though a poor pivot can degrade it to quadratic time. Heapsort uses a heap structure to achieve reliable linearithmic time with little extra memory.\n\nBeyond speed, algorithms differ in other ways. A stable sort preserves the relative order of items that compare equal, which matters when sorting by multiple keys. An in place sort uses little extra memory. These properties often decide which algorithm fits a real situation, since the theoretically fastest choice is not always the most practical.\n\nGratisAPI provides a reference at /api/sorting-algorithms/index.json. Each entry names an algorithm and lists its best, average, and worst case time complexity, along with notes on stability and memory use. Seeing them together makes the trade offs vivid.\n\nStudying sorting is really studying algorithm design in miniature. The same lessons, that clever strategies beat brute force and that no single method is best for every case, apply throughout computer science.",
      "word_count": 328,
      "reading_time_min": 2,
      "try_api": "sorting-algorithms",
      "url": "https://gratisapi.com/api/articles/reference-sorting-algorithms"
    },
    {
      "id": "science-what-makes-a-mammal",
      "title": "What Makes a Mammal",
      "category": "Science",
      "author": "The GratisAPI Team",
      "date": "2024-02-19",
      "tags": [
        "biology",
        "mammals",
        "animals"
      ],
      "summary": "Mammals share a set of defining traits, from hair and milk to warm blood, that set them apart from every other group of animals.",
      "body": "Humans, whales, bats, and elephants may seem to have little in common, yet all belong to the same class of animals: the mammals. Despite their staggering diversity, mammals share a handful of defining features that unite them and distinguish them from birds, reptiles, fish, and amphibians.\n\nThe most famous trait gives the group its name. Female mammals produce milk from mammary glands to nourish their young. This provides newborns with a rich, ready supply of nutrition and antibodies during their most vulnerable days. A second hallmark is hair or fur, which every mammal has at some point in life, even whales that carry only a few whiskers. Hair provides insulation, camouflage, and sensation.\n\nMammals are also warm blooded, meaning they generate their own body heat and maintain a stable internal temperature regardless of their surroundings. This lets them stay active in cold climates and at night, though it demands a great deal of food to fuel. Internally, mammals share other signatures: a four chambered heart that keeps oxygen rich and oxygen poor blood separate, a muscular diaphragm that drives breathing, and three tiny bones in the middle ear that transmit sound with great sensitivity.\n\nMammals are usually divided into three groups by how they reproduce. The vast majority are placental mammals, whose young develop fully inside the mother. Marsupials such as kangaroos give birth to tiny underdeveloped young that finish growing in a pouch. A small and ancient group, the monotremes, including the platypus and echidnas, actually lay eggs yet still produce milk.\n\nMost mammals also have specialized teeth of different shapes for cutting and grinding food. You can explore mammals and other animals through the GratisAPI endpoint at /api/animals/index.json.",
      "word_count": 280,
      "reading_time_min": 1,
      "try_api": "animals",
      "url": "https://gratisapi.com/api/articles/science-what-makes-a-mammal"
    },
    {
      "id": "world-western-zodiac",
      "title": "The Western Zodiac",
      "category": "Culture",
      "author": "The GratisAPI Team",
      "date": "2024-02-14",
      "tags": [
        "zodiac",
        "astrology"
      ],
      "summary": "The Western zodiac divides the year into twelve signs, from Aries to Pisces. This article explains their origins and enduring popularity.",
      "body": "The Western zodiac is one of the most familiar systems of symbols in the world. Ask most people their star sign and they can answer instantly, even if they place no faith in astrology. The system divides the year into twelve signs, each linked to a constellation and a span of dates.\n\nThe twelve signs are Aries, Taurus, Gemini, Cancer, Leo, Virgo, Libra, Scorpio, Sagittarius, Capricorn, Aquarius, and Pisces. They begin with Aries around the spring equinox and proceed through the year, each governing roughly a month. Your sign is determined by where the sun appeared against the stars on the day you were born.\n\nThe system has ancient roots in Babylonian astronomy, later refined by the Greeks, who gave the signs many of the names and mythological associations we use today. The word zodiac itself comes from a Greek term meaning circle of animals, since most of the signs are living creatures.\n\nAstrologers group the signs by four classical elements, fire, earth, air, and water, and by qualities that describe how each sign expresses its energy. From these combinations they draw the personality traits popularly attached to each sign, such as the boldness of Aries or the balance of Libra. Astronomers stress that these associations have no physical basis, and that the constellations have drifted since the signs were fixed.\n\nWhether taken as guidance, entertainment, or cultural shorthand, the zodiac remains woven into daily life, from newspaper horoscopes to conversation. The GratisAPI zodiac dataset at /api/zodiac/index.json lists each sign with its dates, element, and symbol, a clean reference for building horoscope apps, quizzes, or any project that plays with the twelve signs.",
      "word_count": 273,
      "reading_time_min": 1,
      "try_api": "zodiac",
      "url": "https://gratisapi.com/api/articles/world-western-zodiac"
    },
    {
      "id": "freedom-true-cost-of-free-apis",
      "title": "The True Cost of \"Free\" Commercial APIs",
      "category": "Philosophy",
      "author": "The GratisAPI Team",
      "date": "2024-02-14",
      "tags": [
        "apis",
        "cost",
        "lock-in"
      ],
      "summary": "Commercial APIs advertised as free often carry hidden costs in data, dependency, and the constant risk of changing terms.",
      "body": "Many commercial APIs advertise a free tier, and for a developer starting a project the offer is tempting. But free here almost always means gratis in a narrow, conditional sense, and the true cost tends to reveal itself later. Understanding those costs is part of using such services wisely.\n\nThe most familiar cost is the bait and switch. A free tier draws you in, you build your application on it, and then the terms change. Rate limits tighten, prices appear, features move behind payment, or the free tier is quietly discontinued. Because your application now depends on the service, you are poorly positioned to refuse. The initial gratis offer was an investment in your future dependence.\n\nAnother cost is data. When money does not change hands, you are frequently paying with information. Your queries, usage patterns, and sometimes your users' data become the product. A free API can be a sensor pointed at your project, and the value extracted may exceed what a modest fee would have cost.\n\nLock-in is a subtler cost. Proprietary APIs often use unique formats, authentication schemes, and behaviors that make migration difficult. The longer you stay, the more expensive leaving becomes. This is not an accident; friction to exit is a deliberate feature of many business models.\n\nThere is also the fragility of dependence itself. A closed API can vanish, get acquired, deprecate the endpoints you rely on, or suffer an outage you cannot diagnose because you cannot see inside it. You are building on ground you do not control.\n\nNone of this makes commercial APIs illegitimate. Companies must sustain themselves, and paid services can be honest and excellent. The problem is the word free attached to arrangements that are anything but. GratisAPI exists partly as a counterexample: gratis with no hidden bill, and libre so the exit door is never locked.",
      "word_count": 307,
      "reading_time_min": 2,
      "try_api": "quotes",
      "url": "https://gratisapi.com/api/articles/freedom-true-cost-of-free-apis"
    },
    {
      "id": "reference-big-o-notation",
      "title": "Big-O Notation Explained",
      "category": "Reference",
      "author": "The GratisAPI Team",
      "date": "2024-02-09",
      "tags": [
        "big-o",
        "algorithms",
        "cs"
      ],
      "summary": "Big-O notation describes how an algorithm's running time grows as its input gets larger.",
      "body": "When comparing algorithms, the raw time in seconds is misleading because it depends on the machine, the language, and countless other details. Big-O notation offers a better measure. It describes how the work an algorithm does grows as the size of its input grows, ignoring constant factors and focusing on the shape of that growth.\n\nThe idea is to express the number of steps as a function of the input size and keep only the dominant term. If an algorithm takes a fixed number of steps no matter the input, it is constant time, written as order one. If the steps grow in direct proportion to the input, it is linear time. These simple categories let you compare algorithms without running them.\n\nSeveral growth rates appear constantly. Constant time is the ideal, unaffected by input size. Logarithmic time grows very slowly and is typical of algorithms that repeatedly halve the problem, such as binary search. Linear time grows proportionally. The combination called linearithmic time, slightly worse than linear, is the mark of the best general sorting algorithms. Quadratic time, where work grows with the square of the input, becomes painful quickly, and exponential time is impractical for all but tiny inputs.\n\nBig-O describes the worst case, the upper bound on how bad things can get. This matters because it tells you how an algorithm behaves under stress, when the input is large or unfavorable. An algorithm that is fast on small inputs can still be unusable at scale if its growth rate is poor.\n\nThe practical lesson is that growth rate dominates once inputs get large. A quadratic algorithm may beat a linearithmic one on ten items, but on a million items the difference is enormous. This is why understanding Big-O guides real decisions about which approach to use.\n\nGratisAPI complements this with its sorting reference at /api/sorting-algorithms/index.json, where each algorithm is listed with its time complexity. Seeing those complexities side by side turns the abstract theory of Big-O into concrete, comparable numbers.",
      "word_count": 333,
      "reading_time_min": 2,
      "try_api": "sorting-algorithms",
      "url": "https://gratisapi.com/api/articles/reference-big-o-notation"
    },
    {
      "id": "howto-ruby",
      "title": "Consuming GratisAPI in Ruby",
      "category": "Tutorials",
      "author": "The GratisAPI Team",
      "date": "2024-02-09",
      "tags": [
        "ruby",
        "json",
        "net-http"
      ],
      "summary": "Retrieve GratisAPI data in Ruby using the standard net/http and json libraries.",
      "body": "Ruby's standard library covers everything you need to consume GratisAPI. The net/http library handles the request and the json library parses the response, so no gems are required for basic use.\n\nHere is the compact pattern. Require both libraries, build a URI, fetch it, and parse the body:\n\nrequire \"net/http\"\nrequire \"json\"\n\nurl = URI(\"https://gratisapi.com/api/quotes/index.json\")\nresponse = Net::HTTP.get(url)\ndata = JSON.parse(response)\n\nputs \"Loaded #{data['count']} quotes\"\ndata[\"quotes\"].each do |quote|\n  puts \"#{quote['text']} - #{quote['author']}\"\nend\n\nJSON.parse turns the response text into ordinary Ruby hashes and arrays, so you access fields with string keys. Net::HTTP.get is a convenience method that returns the body directly; for more control over status codes and headers, use Net::HTTP.start with a request object instead.\n\nFor cleaner error handling, wrap the call in a begin/rescue block to catch network exceptions, and check the response code when you need to distinguish a missing endpoint from a valid empty result. If you prefer a friendlier interface, popular gems like httparty or faraday reduce the ceremony, but they are optional conveniences rather than requirements.\n\nBecause GratisAPI returns entire collections in a single file, one request hands you the whole dataset to iterate with each, map, or select. This suits Ruby's expressive enumerable methods perfectly. You might select all records matching a condition, map them into a new shape, or sort them before display. Since there are no API keys and no rate limits, a Ruby script can fetch, transform, and present open data in just a handful of lines, whether it runs as a one-off task or inside a Rails application.",
      "word_count": 259,
      "reading_time_min": 1,
      "try_api": "quotes",
      "url": "https://gratisapi.com/api/articles/howto-ruby"
    },
    {
      "id": "world-new-seven-wonders",
      "title": "The New Seven Wonders",
      "category": "Culture",
      "author": "The GratisAPI Team",
      "date": "2024-01-19",
      "tags": [
        "history",
        "wonders"
      ],
      "summary": "In 2007 a global vote chose seven modern wonders from the world's surviving monuments. This article introduces the winners of that campaign.",
      "body": "Because six of the seven ancient wonders have long since crumbled, a modern campaign set out to name a new list of marvels that people could actually visit. In 2007, after a worldwide poll that drew tens of millions of votes, a private foundation announced the New Seven Wonders of the World.\n\nThe winners spanned the globe and thousands of years of history. The Great Wall of China, a vast fortification snaking across northern China, represented one of the largest construction projects ever undertaken. Petra, carved into rose coloured cliffs in Jordan, showcased the artistry of the Nabataean civilisation.\n\nFrom the Americas came Machu Picchu, the mountaintop Inca citadel in Peru, and Chichen Itza, the great Maya pyramid city in Mexico. The towering statue of Christ the Redeemer overlooking Rio de Janeiro represented Brazil and the modern era, being by far the youngest structure on the list.\n\nEurope and Asia contributed two icons of empire and love. The Colosseum in Rome, the mighty amphitheatre where gladiators once fought, stood for the grandeur of the ancient Roman world. The Taj Mahal in India, a white marble mausoleum built by a grieving emperor for his wife, was celebrated as one of the most beautiful buildings ever made.\n\nThe campaign was not without criticism. It was run by a commercial organisation rather than an official body, and the voting was open and unscientific, so the results reflect popularity as much as historical importance. Still, the list succeeded in sparking global interest in cultural heritage. The GratisAPI dataset lets you explore such landmarks and their locations, a useful foundation for travel apps, quizzes, and lessons about the wonders people treasure today.",
      "word_count": 277,
      "reading_time_min": 1,
      "try_api": "elements",
      "url": "https://gratisapi.com/api/articles/world-new-seven-wonders"
    },
    {
      "id": "reference-common-data-structures",
      "title": "Common Data Structures",
      "category": "Reference",
      "author": "The GratisAPI Team",
      "date": "2024-01-16",
      "tags": [
        "data-structures",
        "programming",
        "cs"
      ],
      "summary": "Data structures are the different ways programs organize information to make operations efficient.",
      "body": "A data structure is a way of organizing information inside a program so that it can be used efficiently. Choosing the right structure for a task often matters more than any other decision, because it determines how fast common operations will be. A handful of structures appear again and again across all of computing.\n\nThe array is the most basic. It stores elements in a contiguous block, so you can jump to any position instantly by its index. Arrays are ideal when you know how many items you have and want fast access by position, but inserting into the middle can be slow because other elements must shift.\n\nThe linked list stores each element in its own node that points to the next. This makes inserting and removing items cheap, since you only adjust a few pointers, but reaching a particular item means walking from the start. Stacks and queues are specialized lists: a stack removes the most recently added item first, while a queue removes the oldest first.\n\nThe hash table stores key and value pairs and uses a hash function to place each key in a slot. This gives nearly instant lookup, insertion, and deletion by key on average, which is why hash tables underpin so many programs. Trees organize data hierarchically; a binary search tree keeps items in order so you can search, insert, and delete in time proportional to the tree's depth. Graphs generalize trees to model networks of connections, such as roads or social links.\n\nEach structure trades one strength for another. Arrays give fast indexed access but rigid size; hash tables give fast key lookup but no order; trees give ordered data with efficient search. Knowing these trade offs is the heart of good program design.\n\nGratisAPI provides a reference at /api/data-structures/index.json, with each entry naming a structure and describing its properties and typical operations. It is a compact study aid for interviews or coursework, and a reminder that picking the right container is often the first step toward efficient code.",
      "word_count": 337,
      "reading_time_min": 2,
      "try_api": "data-structures",
      "url": "https://gratisapi.com/api/articles/reference-common-data-structures"
    },
    {
      "id": "howto-php",
      "title": "Consuming GratisAPI in PHP",
      "category": "Tutorials",
      "author": "The GratisAPI Team",
      "date": "2024-01-15",
      "tags": [
        "php",
        "json",
        "web"
      ],
      "summary": "Fetch and decode GratisAPI endpoints in PHP using file_get_contents or cURL.",
      "body": "PHP can consume GratisAPI with nothing more than its built-in functions. Because the endpoints are static JSON files that need no authentication, a one-line fetch followed by a decode is enough.\n\nThe simplest method uses file_get_contents to retrieve the body and json_decode to parse it. Pass true as the second argument to json_decode so you get associative arrays instead of objects:\n\n<?php\n$url = \"https://gratisapi.com/api/colors/index.json\";\n$body = file_get_contents($url);\n$data = json_decode($body, true);\n\necho \"Loaded \" . $data[\"count\"] . \" colors\\n\";\nforeach ($data[\"colors\"] as $color) {\n    echo $color[\"name\"] . \": \" . $color[\"hex\"] . \"\\n\";\n}\n\nFor file_get_contents to fetch a URL, the allow_url_fopen setting must be enabled, which it is by default on most hosts. If it is disabled, or if you need finer control over timeouts and error handling, use the cURL extension instead. With cURL you create a handle, set CURLOPT_RETURNTRANSFER so the body is returned rather than printed, execute the request, and then decode the result.\n\nAlways check that json_decode did not return null, which signals a parse failure, and verify the HTTP status when using cURL so a missing endpoint does not pass silently. Wrapping the logic in a small helper function keeps your calling code tidy.\n\nBecause GratisAPI serves complete collections, a single request gives you the whole dataset to loop over with foreach. This makes it easy to render a table, seed a database, or power a widget on a page. With no keys to store and no rate limits to respect, GratisAPI fits comfortably into any PHP project, from a plain script to a full framework like Laravel where you might wrap the call in an HTTP client service.",
      "word_count": 276,
      "reading_time_min": 1,
      "try_api": "colors",
      "url": "https://gratisapi.com/api/articles/howto-php"
    },
    {
      "id": "science-animal-taxonomy-explained",
      "title": "Animal Taxonomy Explained",
      "category": "Science",
      "author": "The GratisAPI Team",
      "date": "2024-01-13",
      "tags": [
        "biology",
        "taxonomy",
        "animals"
      ],
      "summary": "Taxonomy is the science of naming and classifying living things, organizing the animal kingdom into a nested hierarchy from kingdom down to species.",
      "body": "With millions of animal species sharing the planet, biologists need a systematic way to name and organize them. That system is called taxonomy, and its foundations were laid in the eighteenth century by the Swedish naturalist Carl Linnaeus.\n\nThe heart of the system is a nested hierarchy of ranks. From the broadest to the most specific, the main levels are kingdom, phylum, class, order, family, genus, and species. Each animal belongs to one group at every level. A domestic dog, for instance, belongs to the kingdom Animalia, the phylum Chordata, the class Mammalia, the order Carnivora, the family Canidae, the genus Canis, and the species familiaris. Students often memorize the order with a phrase such as King Philip Came Over For Good Soup.\n\nLinnaeus also gave us binomial nomenclature, the two part scientific name every species carries. The name combines the genus and species, always written in italics with the genus capitalized, as in Canis familiaris or Homo sapiens. This universal naming avoids the confusion of common names, which vary by language and region and sometimes apply to several different animals.\n\nModern taxonomy has evolved beyond simply grouping animals by appearance. Today classification aims to reflect evolutionary relationships, so that groups share a common ancestor. DNA analysis has reshaped parts of the tree of life, sometimes revealing that creatures which look alike are only distantly related, or that unlikely looking animals are close cousins.\n\nUnderstanding these ranks helps make sense of biodiversity and how species relate to one another. You can browse animals along with their classification details through the GratisAPI endpoint at /api/animals/index.json.",
      "word_count": 264,
      "reading_time_min": 1,
      "try_api": "animals",
      "url": "https://gratisapi.com/api/articles/science-animal-taxonomy-explained"
    },
    {
      "id": "freedom-public-domain-and-commons",
      "title": "The Public Domain and the Commons",
      "category": "Philosophy",
      "author": "The GratisAPI Team",
      "date": "2024-01-09",
      "tags": [
        "public-domain",
        "commons",
        "copyright"
      ],
      "summary": "The public domain and the commons describe shared resources that belong to everyone, forming a foundation for free culture and open data.",
      "body": "The public domain is the body of creative and intellectual work that is not owned by anyone. A work enters the public domain when its copyright expires, when it was never eligible for copyright, or when its creator deliberately releases it. Once there, it belongs to everyone and no one, free for any use without permission or payment.\n\nThe public domain is not a wasteland but a treasury. The works of Shakespeare, the music of Bach, foundational scientific results, and countless facts about the world sit in it. Every new creation draws on this shared inheritance, remixing and building upon what came before. A healthy public domain is the soil from which culture grows.\n\nThe commons is a broader idea: resources held and managed collectively rather than owned privately. Historically the word described shared pastures and fisheries. Applied to knowledge, a commons is a pool of information, code, or culture that a community shares and stewards together. Free software, open data, and openly licensed writing all form parts of a knowledge commons.\n\nBoth face pressures. Copyright terms have been extended repeatedly, delaying the entry of works into the public domain and enclosing what might otherwise be shared. Data can be fenced behind restrictive licenses or technical barriers. The economist's warning about a tragedy of the commons is often invoked, though knowledge commons behave differently from grazing land, since information is not depleted by use.\n\nTools like Creative Commons licenses and public domain dedications let creators deliberately contribute to the commons, choosing openness where the law would otherwise impose restriction. They are the cultural counterpart to free software licenses.\n\nGratisAPI draws on public domain and openly licensed data wherever possible, and returns its own work to the commons under the GPL. The commons only endures if people keep contributing to it, and we consider that contribution part of the point.",
      "word_count": 309,
      "reading_time_min": 2,
      "try_api": "cocktails",
      "url": "https://gratisapi.com/api/articles/freedom-public-domain-and-commons"
    },
    {
      "id": "world-seven-wonders-ancient",
      "title": "The Seven Wonders of the Ancient World",
      "category": "Culture",
      "author": "The GratisAPI Team",
      "date": "2023-12-15",
      "tags": [
        "history",
        "wonders"
      ],
      "summary": "Ancient Greek travellers compiled a list of seven astonishing structures, of which only the Great Pyramid survives. This article revisits these lost marvels.",
      "body": "The Seven Wonders of the Ancient World were a list of remarkable structures compiled by Greek writers to celebrate the greatest achievements of their known world. The list was essentially a travel guide, naming the sights a cultured person of the Mediterranean simply had to see.\n\nThe Great Pyramid of Giza is the oldest of the seven and the only one still standing today. Built as a tomb for the pharaoh Khufu more than four and a half thousand years ago, it remained the tallest human made structure on Earth for thousands of years. The other six have all vanished, leaving only descriptions and fragments.\n\nThe Hanging Gardens of Babylon were said to be a tiered paradise of greenery in the Mesopotamian desert, though scholars still debate whether they truly existed. The Statue of Zeus at Olympia and the Temple of Artemis at Ephesus honoured great gods, while the Mausoleum at Halicarnassus was a tomb so magnificent that its name became a word for grand tombs everywhere.\n\nThe Colossus of Rhodes, a giant bronze statue of the sun god, stood over a harbour before an earthquake toppled it. The Lighthouse of Alexandria guided ships into one of the ancient world's greatest ports and stood for centuries before earthquakes finally brought it down.\n\nWhat unites the seven is human ambition on a staggering scale, achieved without modern machinery. That they mostly no longer exist adds a note of melancholy and reminds us that even the grandest works can fade. The GratisAPI seven wonders dataset at /api/seven-wonders/index.json lists each wonder with its location and a short description, a tidy reference for lessons, quizzes, and projects about the marvels of antiquity.",
      "word_count": 278,
      "reading_time_min": 1,
      "try_api": "seven-wonders",
      "url": "https://gratisapi.com/api/articles/world-seven-wonders-ancient"
    },
    {
      "id": "freedom-the-open-data-movement",
      "title": "The Open Data Movement",
      "category": "Philosophy",
      "author": "The GratisAPI Team",
      "date": "2023-12-12",
      "tags": [
        "open-data",
        "movement",
        "transparency"
      ],
      "summary": "The open data movement holds that certain data, especially data funded by the public, should be freely available for anyone to use and share.",
      "body": "The open data movement extends the logic of free software to information itself. Its core belief is that many kinds of data, particularly data gathered by governments and public institutions, should be freely available for anyone to access, use, modify, and share, without restrictive licensing or paywalls.\n\nThe reasoning is partly about fairness. When data collection is paid for by taxpayers, the resulting datasets are in a real sense already owned by the public. Charging citizens again to access what their taxes produced, or locking it behind proprietary formats, is hard to justify. Open data returns that information to the people who funded it.\n\nThe reasoning is also about value. Data left closed is data left inert. When datasets are opened, unexpected uses emerge. Independent researchers verify official findings, journalists uncover patterns, entrepreneurs build services, and civic technologists create tools that improve public life. The same dataset can serve purposes its collectors never imagined.\n\nGood open data follows recognized principles. It should be complete, primary, timely, accessible, machine readable, non-discriminatory, non-proprietary in format, and free of restrictive licenses. Simply publishing a scanned document is not enough; the data must be structured so that machines and people can actually work with it.\n\nThe movement has produced real institutions: government open data portals, international charters, and organizations that rank countries on how openly they publish information. It intersects with open science, open government, and the broader push for transparency.\n\nGratisAPI is a small participant in this movement. By packaging open datasets into a convenient, freely usable API with no keys and no cost, we try to lower the distance between data that is technically public and data that is actually usable. Open in principle means little if it is inconvenient in practice, and closing that gap is part of the work.",
      "word_count": 299,
      "reading_time_min": 1,
      "try_api": "birds",
      "url": "https://gratisapi.com/api/articles/freedom-the-open-data-movement"
    },
    {
      "id": "science-golden-ratio",
      "title": "The Golden Ratio",
      "category": "Science",
      "author": "The GratisAPI Team",
      "date": "2023-12-07",
      "tags": [
        "mathematics",
        "golden-ratio",
        "geometry"
      ],
      "summary": "The golden ratio is a special proportion, roughly 1.618, that appears in geometry, nature, and art and is intimately tied to the Fibonacci sequence.",
      "body": "Among the mathematical constants, few have captured the imagination like the golden ratio. Denoted by the Greek letter phi, it has a value of approximately 1.61803. It is defined by a simple geometric idea: divide a line into two parts so that the ratio of the whole to the longer part equals the ratio of the longer part to the shorter part. Only one proportion satisfies this, and that proportion is the golden ratio.\n\nPhi has some remarkable algebraic properties. Its square equals itself plus one, and its reciprocal equals itself minus one. These tidy relationships fall out directly from its definition and make phi unique among numbers.\n\nThe golden ratio is deeply connected to the Fibonacci sequence, the series in which each number is the sum of the two before it: 1, 1, 2, 3, 5, 8, 13, and so on. As you go further along the sequence, the ratio of each number to the one before it draws ever closer to phi. This link ties the golden ratio to real patterns in nature, since Fibonacci numbers appear in the spiral arrangements of sunflower seeds, pinecones, and the branching of plants, arrangements that pack elements efficiently.\n\nThe golden ratio has a long history in art and architecture, where it is often claimed to produce especially pleasing proportions. Some of these claims are genuine and deliberate, while others are romantic exaggerations read into buildings and paintings after the fact. Either way, the golden rectangle, whose sides are in the golden ratio, remains a favorite tool of designers.\n\nGeometrically, phi is woven into the five pointed star and the regular pentagon, where the ratio of a diagonal to a side is exactly the golden ratio. You can find phi and its properties through the GratisAPI endpoint at /api/math-constants/index.json.",
      "word_count": 297,
      "reading_time_min": 1,
      "try_api": "math-constants",
      "url": "https://gratisapi.com/api/articles/science-golden-ratio"
    },
    {
      "id": "howto-rust",
      "title": "Consuming GratisAPI in Rust",
      "category": "Tutorials",
      "author": "The GratisAPI Team",
      "date": "2023-12-07",
      "tags": [
        "rust",
        "reqwest",
        "serde"
      ],
      "summary": "Use reqwest and serde to fetch and deserialize GratisAPI data into strongly typed Rust structs.",
      "body": "Rust's ecosystem makes HTTP JSON work both safe and ergonomic through two crates: reqwest for requests and serde for deserialization. GratisAPI's static, keyless endpoints are a clean target.\n\nAdd reqwest with the json feature and serde with derive to your Cargo.toml. Then define structs that derive Deserialize and let serde map the JSON automatically:\n\nuse serde::Deserialize;\n\n#[derive(Deserialize)]\nstruct Response {\n    count: u32,\n    quotes: Vec<Quote>,\n}\n\n#[derive(Deserialize)]\nstruct Quote {\n    text: String,\n    author: String,\n}\n\n#[tokio::main]\nasync fn main() -> Result<(), reqwest::Error> {\n    let url = \"https://gratisapi.com/api/quotes/index.json\";\n    let data: Response = reqwest::get(url).await?.json().await?;\n    println!(\"Loaded {} quotes\", data.count);\n    Ok(())\n}\n\nThe json method on the response deserializes the body directly into your typed struct, and the ? operator propagates any error cleanly. Field names in the struct match the JSON keys; use serde's rename attribute when they differ.\n\nThis approach gives you compile-time confidence about the data's shape. If a field is optional, model it as an Option so missing values do not cause a decode failure. For a synchronous program without an async runtime, reqwest offers a blocking client behind a feature flag, which avoids pulling in tokio.\n\nBecause each endpoint returns a full collection, one request yields a Vec you can iterate, filter, and map with Rust's expressive iterator methods. There are no rate limits and no tokens, so the only real concern is the same as everywhere: cache the static files when you fetch them repeatedly, since they change only on redeploy. The result is fast, memory-safe access to open data with almost no boilerplate.",
      "word_count": 255,
      "reading_time_min": 1,
      "try_api": "quotes",
      "url": "https://gratisapi.com/api/articles/howto-rust"
    },
    {
      "id": "reference-css-units",
      "title": "CSS Units Explained",
      "category": "Reference",
      "author": "The GratisAPI Team",
      "date": "2023-12-01",
      "tags": [
        "css",
        "web",
        "layout"
      ],
      "summary": "CSS offers many units of length, split between absolute measures and flexible relative ones.",
      "body": "When you style a web page, nearly every size you set needs a unit. CSS offers a surprising number of them, and choosing well is the difference between a rigid layout and one that adapts gracefully to different screens. The units fall into two broad families: absolute and relative.\n\nAbsolute units describe a fixed physical size. The pixel is the most common; on the web it is a device independent unit that stays roughly constant regardless of screen density. Other absolute units like centimeters and inches exist but are mainly useful for print, where real physical dimensions matter. Absolute units are predictable but do not adapt to a user's settings.\n\nRelative units are where CSS becomes flexible. The em unit is relative to the font size of the current element, so padding set in em scales with the text around it. The rem unit is relative to the root font size, giving a single consistent basis for the whole page and making it easy to scale an entire design. Percentages size an element relative to its parent, which is essential for fluid layouts.\n\nA particularly useful group is the viewport units. One unit of viewport width equals one percent of the browser window's width, and the viewport height unit works the same way for height. These let elements respond directly to the size of the screen, which is invaluable for full page sections and responsive typography.\n\nChoosing units thoughtfully improves both accessibility and responsiveness. Sizing text in rem, for example, respects a user who has increased their default font size, while sizing in fixed pixels ignores that preference.\n\nGratisAPI offers a reference at /api/css-units/index.json listing each unit with its name, category, and a short description. It is handy for building style tools, cheat sheets, or teaching material. Mastering the units frees you from guesswork and lets you build layouts that feel intentional on a phone, a laptop, and a large monitor alike.",
      "word_count": 322,
      "reading_time_min": 2,
      "try_api": "css-units",
      "url": "https://gratisapi.com/api/articles/reference-css-units"
    },
    {
      "id": "world-egyptian-gods",
      "title": "The Gods of Ancient Egypt",
      "category": "Culture",
      "author": "The GratisAPI Team",
      "date": "2023-11-20",
      "tags": [
        "mythology",
        "egyptian"
      ],
      "summary": "Ancient Egypt worshipped a vast pantheon over thousands of years, from the sun god Ra to Osiris, lord of the dead. This article introduces its enduring deities.",
      "body": "The religion of ancient Egypt endured for more than three thousand years, longer than most civilisations have existed at all. Over that immense span the Egyptians worshipped hundreds of gods, whose roles shifted and merged as dynasties rose and fell along the Nile.\n\nMany Egyptian gods were depicted with human bodies and animal heads, a striking convention that expressed each deity's nature. Anubis, guardian of the dead and overseer of mummification, had the head of a jackal. Horus, the sky god and protector of kings, had the head of a falcon. Thoth, god of writing and wisdom, was shown with the head of an ibis.\n\nThe sun stood at the centre of Egyptian belief. Ra, the sun god, sailed across the sky each day in his solar barque and battled the forces of chaos each night to be reborn at dawn. Pharaohs claimed close kinship with the gods, and their vast temples and tombs were built to sustain this cosmic order.\n\nPerhaps the most beloved story was that of Osiris, the god of the afterlife who was murdered by his jealous brother Set, restored by his devoted wife Isis, and became ruler of the dead. Their son Horus avenged him, and the tale gave Egyptians hope of their own resurrection. The famous weighing of the heart determined whether a soul was worthy of eternal life.\n\nThese beliefs shaped some of humanity's most enduring monuments, from the pyramids to the temples of Karnak. The GratisAPI Egyptian gods dataset at /api/egyptian-gods/index.json lists the major deities with their domains and symbols, a clean foundation for study, games, or creative projects drawing on the mysteries of the Nile.",
      "word_count": 274,
      "reading_time_min": 1,
      "try_api": "egyptian-gods",
      "url": "https://gratisapi.com/api/articles/world-egyptian-gods"
    },
    {
      "id": "freedom-why-gratisapi-is-both-free",
      "title": "Why GratisAPI Is Both Free and Free",
      "category": "Philosophy",
      "author": "The GratisAPI Team",
      "date": "2023-11-18",
      "tags": [
        "gratisapi",
        "gratis",
        "libre"
      ],
      "summary": "GratisAPI is deliberately free in both senses of the word: it costs nothing and it respects your freedom to use and reshape it.",
      "body": "The name GratisAPI contains a small joke with a serious point. It is free in both senses that the English word confusingly combines: gratis, meaning it costs nothing, and libre, meaning it respects your freedom. Most services that call themselves free deliver only the first, and often not even that once you count the hidden costs.\n\nOn the gratis side, the promise is plain. There is no fee to use GratisAPI, no paid tier that unlocks the real functionality, and no invoice waiting at the end of a trial. You do not need a credit card on file. The data is there to be used, at no monetary cost, by anyone.\n\nOn the libre side, the promise runs deeper. The data and the code that produces it are released under the GPL, a strong copyleft license. That means you may study exactly how the API is built, modify it to suit your needs, run your own copy, and redistribute your version to others. If GratisAPI ever disappoints you or disappears, you are not stranded, because you can take everything and continue.\n\nThese two properties reinforce each other. A gratis-only service can lure you in and then change the terms, because you have no way to leave. A libre-only service might respect your freedom in principle but still charge in ways that exclude people. Combining both closes those gaps: the price is zero and the exit is always open.\n\nWe also try to honor the spirit behind the freedoms. GratisAPI is static and requires no keys, sets no trackers, and imposes no artificial scarcity. The goal is that using it should feel like drawing water from a public well rather than renting access from a landlord.\n\nBeing both kinds of free is not a marketing angle. It is the entire reason the project exists.",
      "word_count": 303,
      "reading_time_min": 2,
      "try_api": "countries",
      "url": "https://gratisapi.com/api/articles/freedom-why-gratisapi-is-both-free"
    },
    {
      "id": "science-math-constants-beyond-pi",
      "title": "Mathematical Constants Beyond Pi",
      "category": "Science",
      "author": "The GratisAPI Team",
      "date": "2023-11-16",
      "tags": [
        "mathematics",
        "constants",
        "numbers"
      ],
      "summary": "Beyond the familiar pi lies a rich world of mathematical constants like e and the square root of two, each capturing a deep truth about numbers.",
      "body": "Almost everyone knows pi, the ratio of a circle's circumference to its diameter, roughly 3.14159. But pi is only the most famous member of a large family of mathematical constants, fixed numbers that arise again and again across mathematics and carry deep meaning.\n\nStanding beside pi in importance is e, sometimes called Euler's number, approximately 2.71828. It is the natural base of exponential growth and decay, appearing wherever something grows in proportion to its current size, from compound interest to radioactive decay to population models. The function that is its own derivative is built on e, which makes it indispensable in calculus.\n\nAnother ancient constant is the square root of two, about 1.41421, the length of the diagonal of a unit square. Its discovery by the ancient Greeks was momentous because it is irrational, meaning it cannot be written as a simple fraction. Legend holds that this revelation deeply unsettled the Pythagoreans, who had believed all numbers were ratios of whole numbers.\n\nSome constants remain mysterious. The Euler Mascheroni constant, near 0.5772, links the harmonic series to the natural logarithm, yet mathematicians still do not know whether it is even irrational. Others, like Euler's number and pi, have been proven not only irrational but transcendental, meaning they are not the solution to any simple polynomial equation.\n\nWhat unites these numbers is that they are not arbitrary. Each one is forced into existence by the structure of mathematics itself, and each shows up unexpectedly in fields far from where it was first found. The elegant identity linking e, pi, i, one, and zero is often called the most beautiful equation in mathematics.\n\nYou can explore the values and descriptions of these numbers through the GratisAPI endpoint at /api/math-constants/index.json.",
      "word_count": 287,
      "reading_time_min": 1,
      "try_api": "math-constants",
      "url": "https://gratisapi.com/api/articles/science-math-constants-beyond-pi"
    },
    {
      "id": "howto-go",
      "title": "Consuming GratisAPI in Go",
      "category": "Tutorials",
      "author": "The GratisAPI Team",
      "date": "2023-11-13",
      "tags": [
        "go",
        "http",
        "json"
      ],
      "summary": "Fetch a GratisAPI endpoint in Go using net/http and decode it into typed structs.",
      "body": "Go's standard library includes everything needed to consume GratisAPI: an HTTP client in net/http and a JSON decoder in encoding/json. Because the endpoints are static and keyless, the code is short and dependency-free.\n\nGo encourages decoding JSON into typed structs. Define a struct that mirrors the fields you care about, then decode the response body into it:\n\npackage main\n\nimport (\n    \"encoding/json\"\n    \"fmt\"\n    \"net/http\"\n)\n\ntype Response struct {\n    Count  int `json:\"count\"`\n    Quotes []struct {\n        Text   string `json:\"text\"`\n        Author string `json:\"author\"`\n    } `json:\"quotes\"`\n}\n\nfunc main() {\n    resp, err := http.Get(\"https://gratisapi.com/api/quotes/index.json\")\n    if err != nil { panic(err) }\n    defer resp.Body.Close()\n\n    var data Response\n    json.NewDecoder(resp.Body).Decode(&data)\n    fmt.Printf(\"Loaded %d quotes\\n\", data.Count)\n}\n\nThe struct tags map JSON keys to Go fields. You only need to declare the fields you intend to use; the decoder ignores the rest. Always defer resp.Body.Close() to release the connection, and in production check the error returned by Decode as well as the HTTP status code.\n\nGo's static typing gives you an early guarantee that your code and the data agree in shape. If you would rather stay dynamic, decode into a map[string]interface{} instead, though structs are clearer and safer for known schemas.\n\nBecause GratisAPI returns whole collections at once, a single http.Get gives you the full dataset to range over. This fits Go's concurrency model well: you can fire off several requests in goroutines and collect the results through channels, all against static files that impose no rate limits and require no authentication.",
      "word_count": 245,
      "reading_time_min": 1,
      "try_api": "quotes",
      "url": "https://gratisapi.com/api/articles/howto-go"
    },
    {
      "id": "reference-color-models",
      "title": "Color Models: Hex, RGB and HSL",
      "category": "Reference",
      "author": "The GratisAPI Team",
      "date": "2023-11-08",
      "tags": [
        "colors",
        "css",
        "design"
      ],
      "summary": "Digital colors can be described in several ways, including hexadecimal, RGB, and HSL notations.",
      "body": "Screens create color by mixing three primary lights: red, green, and blue. Every color you see on a display is some combination of these three, and the different color models are simply different ways of writing down that combination.\n\nThe RGB model states the intensity of each primary directly. Each channel usually ranges from 0 to 255, so pure red is 255 red, 0 green, 0 blue. Mixing full red and full green with no blue gives yellow, while equal amounts of all three produce shades of gray, from black at zero to white at maximum. Because it maps directly to the hardware, RGB is the most fundamental model.\n\nHexadecimal notation is just RGB written more compactly. Instead of three decimal numbers, each channel is written as a two digit hexadecimal value, joined into a six digit code preceded by a hash. So the same pure red becomes a familiar code where red is at its maximum and the other channels are zero. Designers favor hex because it is short and easy to paste into stylesheets.\n\nHSL takes a different, more human approach. It describes a color by its hue, an angle around the color wheel; its saturation, how vivid or gray it is; and its lightness, how bright it is. HSL is often easier to reason about when you want to adjust a color, since you can shift the hue or dim the lightness without recomputing three separate channels.\n\nAll three models can describe the same color; they are just different coordinate systems for the same space. Converting between them is a matter of arithmetic, and good tools do it automatically.\n\nGratisAPI provides a color reference at /api/colors/index.json, where each entry lists a name alongside its hex, RGB, and often HSL values. This makes it easy to build palettes, swatches, or conversion tools without deriving the numbers yourself. Understanding the three models lets you pick whichever is most convenient for the task, whether you are matching a brand color or generating a smooth gradient.",
      "word_count": 335,
      "reading_time_min": 2,
      "try_api": "colors",
      "url": "https://gratisapi.com/api/articles/reference-color-models"
    },
    {
      "id": "freedom-free-software-vs-open-source",
      "title": "Free Software vs Open Source",
      "category": "Philosophy",
      "author": "The GratisAPI Team",
      "date": "2023-10-30",
      "tags": [
        "open-source",
        "free-software",
        "movements"
      ],
      "summary": "Free software and open source describe nearly the same set of programs but rest on different values and rhetoric.",
      "body": "Free software and open source refer to substantially the same collection of programs, yet they arise from different philosophies. Understanding the distinction clarifies debates that can otherwise seem like mere quibbling over words.\n\nThe free software movement, led by the Free Software Foundation, frames its case in terms of ethics and liberty. Its central claim is that users have a right to control the software they run, and that proprietary software wrongs them by denying that control. Freedom is the goal, and the practical benefits are welcome consequences.\n\nThe term open source was introduced in 1998 by people who wanted to promote the same development practices to businesses without the moral framing. The Open Source Initiative maintains the Open Source Definition, which in practice recognizes nearly the same licenses the FSF approves. Its rhetoric emphasizes practical advantages: better code quality, faster development, and reliability that come from open collaboration.\n\nBecause the two definitions cover almost the same programs, a given piece of software is usually both free and open source at once. Some people use the combined term FOSS, or FLOSS to include libre, precisely to sidestep the disagreement.\n\nThe difference is one of emphasis and values rather than which software qualifies. Free software advocates worry that focusing only on practical benefits leaves out the ethical core and makes it easier to compromise on freedom when convenient. Open source advocates counter that a pragmatic message reaches audiences that moral arguments do not.\n\nGratisAPI is comfortable being called both. Our license, the GPL, is approved by both the FSF and the OSI, so the code is free software and open source simultaneously. But we lean toward the language of freedom, because our reason for existing is not merely that open data is efficient. It is that access to public data should be a right, not a privilege.",
      "word_count": 306,
      "reading_time_min": 2,
      "try_api": "constellations",
      "url": "https://gratisapi.com/api/articles/freedom-free-software-vs-open-source"
    },
    {
      "id": "howto-bash-jq",
      "title": "Using GratisAPI in Bash Scripts with jq",
      "category": "Tutorials",
      "author": "The GratisAPI Team",
      "date": "2023-10-16",
      "tags": [
        "bash",
        "jq",
        "cli"
      ],
      "summary": "Combine curl and jq to filter, transform, and extract fields from GratisAPI data in shell scripts.",
      "body": "The combination of curl and jq turns the shell into a capable JSON processing environment. GratisAPI's static endpoints make it easy to script data pulls, extract specific fields, and feed results into other commands.\n\njq is a lightweight command-line JSON processor. Install it from your package manager, then pipe curl output into it. To list every quote's author, fetch the endpoint and select the field:\n\ncurl -s https://gratisapi.com/api/quotes/index.json | jq '.quotes[].author'\n\nThe filter .quotes[] iterates the array, and .author picks one field from each record. You can build up more complex expressions. To count records, use jq '.count'. To grab a random item, combine jq with shell tools, or use jq's own functions to select and slice.\n\njq shines at reshaping data. The following pulls just the id and name from the colors collection into compact objects:\n\ncurl -s .../api/colors/index.json | jq '.colors[] | {id, name}'\n\nYou can filter with select, for example .colors[] | select(.name | startswith(\"Dark\")) to keep only colors whose name begins with a given prefix. Add the -r flag to jq for raw output without quotes, which is ideal when you want to feed values into a loop or another command.\n\nA common pattern is a script that downloads a collection, extracts a list of ids, and loops over them to fetch individual records. Because there are no rate limits, such loops run freely, though caching the initial download avoids redundant network calls. With just curl, jq, and a few lines of Bash, you can automate reporting, generate CSV, or drive other tools entirely from GratisAPI data.",
      "word_count": 261,
      "reading_time_min": 1,
      "try_api": "quotes",
      "url": "https://gratisapi.com/api/articles/howto-bash-jq"
    },
    {
      "id": "world-norse-mythology-primer",
      "title": "A Primer on Norse Mythology",
      "category": "Culture",
      "author": "The GratisAPI Team",
      "date": "2023-10-11",
      "tags": [
        "mythology",
        "norse"
      ],
      "summary": "Norse mythology tells of gods, giants, and a world tree, all moving toward a foretold doom called Ragnarok. This article introduces its striking cosmology.",
      "body": "Norse mythology, the belief system of the medieval Scandinavians and their ancestors, offers one of the most vivid and fatalistic visions of the cosmos in world tradition. Its gods know they are doomed and fight on regardless, which gives the whole mythology a heroic, tragic grandeur.\n\nAt the centre stands Yggdrasil, an immense world tree whose roots and branches connect nine worlds. These include Asgard, home of the gods; Midgard, the realm of humans; and Jotunheim, land of the giants who are the gods' perpetual rivals. The whole structure is alive with creatures gnawing at its roots and perched in its branches.\n\nThe gods fall into two families, the Aesir and the Vanir, who fought a war before making peace. Odin, the one eyed all father, rules the Aesir and constantly seeks wisdom, even sacrificing an eye and hanging himself on the world tree to gain knowledge of the runes. Thor, his son, defends gods and humans with his hammer Mjolnir, while the trickster Loki blurs the line between ally and enemy.\n\nWhat sets Norse myth apart is its ending. The gods know a final battle called Ragnarok is coming, in which many of them, including Odin and Thor, will die and the world will be consumed by fire and flood. Yet the myths promise that a new, green world will rise afterward, giving the darkness a thread of hope.\n\nMuch of what survives comes from Icelandic texts written down after the region had already converted to Christianity. The GratisAPI Norse gods dataset at /api/norse-gods/index.json lists the major deities with their domains and symbols, a useful resource for games, study, or creative work inspired by this stark and powerful tradition.",
      "word_count": 280,
      "reading_time_min": 1,
      "try_api": "norse-gods",
      "url": "https://gratisapi.com/api/articles/world-norse-mythology-primer"
    },
    {
      "id": "science-speed-of-light",
      "title": "The Speed of Light",
      "category": "Science",
      "author": "The GratisAPI Team",
      "date": "2023-10-11",
      "tags": [
        "physics",
        "light",
        "relativity"
      ],
      "summary": "Light travels at a fixed cosmic speed limit that no object with mass can reach, a fact that reshaped our understanding of space and time.",
      "body": "Light moves fast, so fast that for most of human history people assumed it traveled instantly. In fact it has a definite speed, and that speed turns out to be one of the most important numbers in all of physics. In a vacuum, light travels at almost exactly 299,792,458 meters per second, a value so fundamental that the meter is now defined in terms of it.\n\nThe speed of light, usually written as the letter c, is not merely how fast light happens to go. It is the universe's ultimate speed limit. Nothing carrying mass or information can travel faster. This cap emerges from Albert Einstein's theory of special relativity, published in 1905, which took as its starting point the strange experimental fact that light always moves at the same speed regardless of how fast the observer is moving.\n\nThat single idea has profound consequences. To keep the speed of light constant for everyone, space and time themselves must bend and stretch. Moving clocks run slow, moving objects contract along their direction of travel, and observers moving relative to one another disagree about what events happen simultaneously. Mass and energy prove to be interchangeable, captured in the famous equation relating energy to mass times the speed of light squared.\n\nBecause light has a finite speed, looking out into space is also looking back in time. Sunlight takes about eight minutes to reach Earth, so we always see the Sun as it was eight minutes ago. Light from distant galaxies has traveled for billions of years, showing us the universe as it appeared in its youth.\n\nThe speed of light in a vacuum is one of the key entries you can find through the GratisAPI endpoint at /api/physical-constants/index.json.",
      "word_count": 287,
      "reading_time_min": 1,
      "try_api": "physical-constants",
      "url": "https://gratisapi.com/api/articles/science-speed-of-light"
    },
    {
      "id": "reference-swagger-ui",
      "title": "Swagger UI Explained",
      "category": "Reference",
      "author": "The GratisAPI Team",
      "date": "2023-10-05",
      "tags": [
        "swagger",
        "openapi",
        "documentation"
      ],
      "summary": "Swagger UI turns an OpenAPI document into an interactive web page for exploring and testing an API.",
      "body": "Writing an OpenAPI document describes an API precisely, but a raw specification file is not much fun to read. Swagger UI bridges that gap. It is a tool that takes an OpenAPI document and renders it as a friendly, interactive web page where anyone can explore the API.\n\nWhen you open a Swagger UI page, you see a tidy list of every operation the API offers, grouped and labeled. Expanding an operation reveals its description, the parameters it accepts, and the responses it can return, all drawn directly from the OpenAPI file. Because the page is generated from the specification, it never falls out of sync with the documented contract.\n\nThe feature that makes Swagger UI special is the try it out button. Rather than copying details into a separate tool, you can fill in parameters and send a real request straight from the documentation page. The response appears immediately, including the status code, the headers, and the body. This turns documentation into a hands on playground and dramatically shortens the time it takes to learn an unfamiliar API.\n\nSwagger UI grew out of the Swagger project, which later evolved into the OpenAPI standard. The name Swagger stuck for the tooling even after the specification was renamed, which is why you often see both terms together. The tool is widely used because it is free, works in any browser, and needs only a valid specification file to function.\n\nGratisAPI publishes an openapi.json file that any Swagger UI instance can load, letting you browse and test every dataset endpoint interactively. Pointing the tool at that file gives you a live catalog of the whole service.\n\nFor anyone building or consuming APIs, Swagger UI is a small investment with a large payoff. It transforms a static description into an interactive guide, making it easier for newcomers to understand a service and for maintainers to demonstrate exactly how it behaves.",
      "word_count": 317,
      "reading_time_min": 2,
      "try_api": "animals",
      "url": "https://gratisapi.com/api/articles/reference-swagger-ui"
    },
    {
      "id": "freedom-gplv2-vs-gplv3",
      "title": "GPLv2 vs GPLv3",
      "category": "Philosophy",
      "author": "The GratisAPI Team",
      "date": "2023-09-21",
      "tags": [
        "gpl",
        "gplv2",
        "gplv3"
      ],
      "summary": "The two major versions of the GPL share a purpose but differ on patents, hardware locks, and license compatibility.",
      "body": "The GNU General Public License exists in two major versions still in wide use. Version 2 was published in 1991 and version 3 in 2007. Both are strong copyleft licenses built on the same four freedoms, but they differ in important ways shaped by sixteen years of legal and technological change.\n\nGPLv2 is short and direct. It grants the freedoms, imposes the copyleft requirement, and demands source availability. For many years it was the default license of the free software world, and enormously influential software, including the Linux kernel, remains under it.\n\nGPLv3 addressed problems that had emerged since 1991. One was tivoization, a practice in which hardware accepts only manufacturer-signed software, so that even though users receive source code, the device refuses to run their modified versions. GPLv3 adds terms requiring that the information needed to install modified versions be provided for certain products, closing that loophole in the spirit of freedom.\n\nGPLv3 also strengthened patent provisions, aiming to prevent distributors from using patent claims to undermine users' freedoms, and it responded to patent agreements of the era. In addition, it improved compatibility with several other free licenses and clarified international legal language.\n\nThese changes were not universally welcomed. Some projects, notably the Linux kernel, chose to stay on GPLv2, in part because relicensing would require agreement from a vast number of contributors and in part due to disagreement with the new terms. This illustrates that moving between versions is a real decision with real costs.\n\nAuthors often license their work as a given version or later, which lets users choose a newer version if they prefer. GratisAPI uses GPL-2.0-or-later, embracing that flexibility. Understanding the differences helps explain why the choice of a small version number can carry significant consequences.",
      "word_count": 291,
      "reading_time_min": 1,
      "try_api": "elements",
      "url": "https://gratisapi.com/api/articles/freedom-gplv2-vs-gplv3"
    },
    {
      "id": "reference-what-is-openapi",
      "title": "What is OpenAPI?",
      "category": "Reference",
      "author": "The GratisAPI Team",
      "date": "2023-09-14",
      "tags": [
        "openapi",
        "api",
        "documentation"
      ],
      "summary": "OpenAPI is a standard format for describing REST APIs in a machine readable document.",
      "body": "An API is only useful if people know how to call it. Traditionally that knowledge lived in prose documentation, which could drift out of date and be read differently by different developers. OpenAPI solves this by describing an API in a precise, machine readable document.\n\nOpenAPI, formerly known as Swagger, is a specification for writing these descriptions. An OpenAPI document lists every address the API exposes, the methods each one accepts, the parameters it expects, and the shape of the data it returns. It is usually written in JSON or the closely related YAML format, so both humans and programs can read it.\n\nThe value of a machine readable description is that tools can act on it. From a single OpenAPI file, you can automatically generate interactive documentation, client libraries in many languages, request validators, and even mock servers for testing. This removes a great deal of tedious hand work and keeps the description and the real behavior in step.\n\nAn OpenAPI document has a clear structure. It declares the version of the specification, general information about the API, and a collection of paths. Under each path sit the operations, and each operation describes its parameters and its possible responses, including the status codes it may return. Reusable data shapes are defined once and referenced throughout, keeping the document tidy.\n\nGratisAPI ships its own description as an openapi.json file at the root of the project. That single file documents every dataset endpoint, so tools can discover what is available without guessing. It is a practical demonstration of the idea: one authoritative file describing the whole service.\n\nLearning OpenAPI pays off whether you build APIs or consume them. As a producer, you get free documentation and tooling. As a consumer, you get a reliable map of exactly how to talk to a service. In both roles, a good OpenAPI document turns an API from a mystery into a contract you can trust.",
      "word_count": 321,
      "reading_time_min": 2,
      "try_api": "countries",
      "url": "https://gratisapi.com/api/articles/reference-what-is-openapi"
    },
    {
      "id": "science-physical-constants",
      "title": "Physical Constants That Shape Reality",
      "category": "Science",
      "author": "The GratisAPI Team",
      "date": "2023-09-09",
      "tags": [
        "physics",
        "constants",
        "fundamental"
      ],
      "summary": "A handful of fixed numbers, from the gravitational constant to Planck's constant, govern the behavior of the entire physical universe.",
      "body": "The laws of physics are written in the language of mathematics, and threaded through those equations are certain fixed numbers that never change no matter where or when you measure them. These physical constants set the scale of reality itself, and even slight differences in their values would produce a universe unrecognizable to us.\n\nSome constants govern the fundamental forces. The gravitational constant, denoted G, fixes the strength of gravity and determines how planets orbit and galaxies hold together. The elementary charge sets the size of the electric charge carried by a single proton or electron. The Coulomb constant scales the force between charged particles.\n\nOthers define the very grain of nature. Planck's constant, symbolized h, sits at the heart of quantum mechanics and describes the smallest possible chunks, or quanta, of energy. Its tiny value explains why quantum effects dominate the atomic world yet vanish in everyday life. The Boltzmann constant links the temperature of a substance to the energy of its individual particles, bridging the microscopic and the thermal.\n\nA few constants are so important that scientists have redefined the units of measurement around them. Since 2019 the kilogram, the ampere, and other base units are anchored to exact fixed values of constants like Planck's constant and the elementary charge, rather than to physical artifacts. This makes the entire system of measurement reproducible in any laboratory on Earth.\n\nPerhaps most intriguing are the dimensionless constants, pure numbers with no units, such as the fine structure constant near one over 137, which controls the strength of electromagnetic interactions. Physicists still cannot explain why it has the value it does.\n\nYou can look up the values and symbols of key physical constants through the GratisAPI endpoint at /api/physical-constants/index.json.",
      "word_count": 288,
      "reading_time_min": 1,
      "try_api": "physical-constants",
      "url": "https://gratisapi.com/api/articles/science-physical-constants"
    },
    {
      "id": "howto-curl-basics",
      "title": "curl Basics for GratisAPI",
      "category": "Tutorials",
      "author": "The GratisAPI Team",
      "date": "2023-09-05",
      "tags": [
        "curl",
        "cli",
        "http"
      ],
      "summary": "Explore GratisAPI endpoints straight from your terminal with the ubiquitous curl command.",
      "body": "curl is installed almost everywhere and is the fastest way to poke at a GratisAPI endpoint without writing any code. Since the API needs no keys and no special headers, a plain GET is all it takes.\n\nRequest an endpoint by passing its URL:\n\ncurl https://gratisapi.com/api/quotes/index.json\n\nThat prints the raw JSON to your terminal. To make it readable, add the silent flag and pipe the output through a formatter. If you have Python available, curl -s URL | python3 -m json.tool pretty-prints the result with no extra tools to install.\n\nA few flags are worth knowing. The -s flag silences the progress meter so only the body prints. The -o filename flag saves the response to a file, which is handy for snapshotting a dataset. The -I flag fetches only the headers, useful for checking the content type or caching headers without downloading the whole body. The -L flag follows redirects, though GratisAPI URLs are direct.\n\nTo inspect response headers and body together, use -i. To see the caching behavior, look at the Cache-Control and ETag headers in the response, since GitHub Pages serves these static files with cache-friendly headers.\n\nYou can also fetch a single item rather than a whole collection. Endpoints follow a predictable pattern, so a specific record lives at a URL like /api/quotes/{id}.json where id is the record's identifier. This means curl is enough not only to browse collections but also to grab individual entries. For quick verification, exploration, or shell scripting, curl remains the simplest entry point into the entire API.",
      "word_count": 256,
      "reading_time_min": 1,
      "try_api": "quotes",
      "url": "https://gratisapi.com/api/articles/howto-curl-basics"
    },
    {
      "id": "world-twelve-olympians",
      "title": "The Twelve Olympian Gods",
      "category": "Culture",
      "author": "The GratisAPI Team",
      "date": "2023-09-03",
      "tags": [
        "mythology",
        "greek"
      ],
      "summary": "At the heart of Greek religion stood twelve great gods who ruled from Mount Olympus. This article introduces the principal members of that divine council.",
      "body": "At the centre of Greek mythology sat the twelve Olympians, the principal gods who ruled the cosmos from their palaces on Mount Olympus. Though ancient sources sometimes disagree on the exact roster, a core group appears again and again as the governing council of the divine world.\n\nZeus was their king, god of the sky and thunder, whose authority the others acknowledged even as they schemed around him. His siblings included Hera, goddess of marriage and his frequently wronged wife; Poseidon, lord of the sea and earthquakes; and Demeter, goddess of the harvest whose grief for her lost daughter explained the changing seasons.\n\nThe next generation, mostly children of Zeus, filled out the council. Athena, born from her father's head, was goddess of wisdom and strategic war. Apollo governed the sun, music, and prophecy, while his twin Artemis ruled the hunt and the wild. Ares embodied the brutality of battle, Aphrodite presided over love and beauty, and Hephaestus, the divine smith, forged wonders at his crooked forge.\n\nRounding out the group were Hermes, the swift messenger and god of travellers and thieves, and either Hestia, gentle goddess of the hearth, or Dionysus, god of wine and ecstasy, depending on the tradition. Hades, though a brother of Zeus, was usually excluded because he dwelt in the underworld rather than on Olympus.\n\nEach god had recognisable symbols and domains that made them easy to identify in art: Zeus with his eagle and thunderbolt, Poseidon with his trident, Athena with her owl. The GratisAPI Greek gods dataset at /api/greek-gods/index.json captures these attributes in a clean format, ideal for building quizzes, family trees, or games that draw on the enduring cast of Olympus.",
      "word_count": 279,
      "reading_time_min": 1,
      "try_api": "greek-gods",
      "url": "https://gratisapi.com/api/articles/world-twelve-olympians"
    },
    {
      "id": "howto-pandas",
      "title": "Loading GratisAPI Data into pandas",
      "category": "Tutorials",
      "author": "The GratisAPI Team",
      "date": "2023-08-19",
      "tags": [
        "python",
        "pandas",
        "data"
      ],
      "summary": "Turn a GratisAPI collection into a pandas DataFrame for quick analysis and exploration.",
      "body": "GratisAPI collections are lists of uniform records, which is exactly the shape pandas loves. In a few lines you can pull an endpoint into a DataFrame and start slicing, filtering, and aggregating.\n\nThe simplest route is to fetch the JSON and hand the list of records to the DataFrame constructor:\n\nimport requests\nimport pandas as pd\n\nurl = \"https://gratisapi.com/api/elements/index.json\"\ndata = requests.get(url, timeout=10).json()\ndf = pd.DataFrame(data[\"elements\"])\n\nprint(df.head())\nprint(df.describe())\n\nBecause each endpoint wraps its records under a named key, point the DataFrame at that inner list rather than the whole response object. Once loaded, the full power of pandas is available. You can sort by a column, filter with boolean masks, group and aggregate, or compute summary statistics with describe.\n\nFor example, with the elements collection you could compute the average atomic mass by group, or select all elements discovered in a given century. With the countries collection you could sort by population or filter by continent. Since GratisAPI returns entire datasets in one request, the whole collection is already in memory, so every operation is fast and offline after that first call.\n\nIf you prefer, pandas can even read JSON directly with pd.read_json, though pulling the record list out yourself gives you more control over nested fields. For nested structures, pd.json_normalize flattens objects into columns. When you are done exploring, export the DataFrame to CSV or Parquet with to_csv or to_parquet to snapshot the data locally. This pattern makes GratisAPI a convenient, no-friction source of clean example datasets for teaching, prototyping, and quick analysis.",
      "word_count": 254,
      "reading_time_min": 1,
      "try_api": "elements",
      "url": "https://gratisapi.com/api/articles/howto-pandas"
    },
    {
      "id": "freedom-gnu-gpl-explained",
      "title": "The GNU General Public License Explained",
      "category": "Philosophy",
      "author": "The GratisAPI Team",
      "date": "2023-08-15",
      "tags": [
        "gpl",
        "licensing",
        "copyleft"
      ],
      "summary": "The GPL is the most widely used copyleft license, granting the four freedoms while requiring that derived works remain free.",
      "body": "The GNU General Public License, or GPL, is the most widely used free software license and the flagship expression of copyleft. Written originally by Richard Stallman for the GNU Project and maintained by the Free Software Foundation, it turns the four essential freedoms into concrete, enforceable legal terms.\n\nAt its core the GPL makes a bargain. It grants every recipient the freedom to run, study, modify, and redistribute the software. In exchange, it requires that if you distribute the software or a modified version, you do so under the same license and make the corresponding source code available. This is the copyleft condition, and it is what keeps GPL software free through every generation of derivation.\n\nA crucial detail concerns source code. The GPL insists that whoever receives a binary must be able to obtain the source, because without source the freedoms to study and modify are hollow. Distributing a compiled GPL program while withholding its source violates the license.\n\nThe GPL does not forbid selling software or using it commercially. You may charge whatever you like for copies or services. What you may not do is strip away the freedoms from those you distribute to. Commerce and freedom coexist; only the removal of freedom is prohibited.\n\nThe license has appeared in several versions. Version 2 was published in 1991 and version 3 in 2007, each responding to the legal and technological landscape of its time. Related licenses, such as the Lesser GPL and the Affero GPL, adapt the same principles to libraries and networked software respectively.\n\nGratisAPI is licensed GPL-2.0-or-later. That means anyone may use and build on our work, but the freedoms must travel with it. The GPL is the legal backbone that makes our promise of libre software something more than a good intention.",
      "word_count": 297,
      "reading_time_min": 1,
      "try_api": "birds",
      "url": "https://gratisapi.com/api/articles/freedom-gnu-gpl-explained"
    },
    {
      "id": "science-moons-of-the-solar-system",
      "title": "The Moons of the Solar System",
      "category": "Science",
      "author": "The GratisAPI Team",
      "date": "2023-08-14",
      "tags": [
        "astronomy",
        "moons",
        "solar-system"
      ],
      "summary": "The solar system hosts hundreds of moons, ranging from tiny captured rocks to worlds larger than the planet Mercury.",
      "body": "Planets rarely travel alone. Circling most of them are moons, natural satellites that range from irregular chunks of rock a few kilometers across to giant worlds with atmospheres and underground oceans. The solar system contains hundreds of confirmed moons, and the count keeps rising as astronomers spot ever smaller ones.\n\nEarth has just one Moon, but it is unusually large relative to its planet and stabilizes our climate by keeping the tilt of Earth's axis steady. The gas and ice giants, by contrast, command whole swarms of satellites. Jupiter and Saturn each have dozens of confirmed moons, while Mercury and Venus have none at all.\n\nSome moons are remarkable worlds in their own right. Jupiter's Ganymede is the largest moon in the solar system, bigger than the planet Mercury, and it even generates its own magnetic field. Saturn's Titan is wrapped in a thick orange atmosphere and has lakes of liquid methane on its surface. Several icy moons, including Jupiter's Europa and Saturn's Enceladus, are believed to hide vast oceans of liquid water beneath their frozen crusts, making them prime targets in the search for life beyond Earth. Enceladus even sprays plumes of water vapor into space through cracks near its south pole.\n\nMoons form in several ways. Large regular moons often condense from disks of debris around a newborn planet, while small irregular ones are frequently asteroids or comets captured by a planet's gravity. Mars owes its two tiny lumpy moons, Phobos and Deimos, to just such a capture.\n\nYou can browse notable moons across the solar system, along with the planets they orbit, through the GratisAPI endpoint at /api/moons/index.json.",
      "word_count": 271,
      "reading_time_min": 1,
      "try_api": "moons",
      "url": "https://gratisapi.com/api/articles/science-moons-of-the-solar-system"
    },
    {
      "id": "world-greek-mythology-primer",
      "title": "A Primer on Greek Mythology",
      "category": "Culture",
      "author": "The GratisAPI Team",
      "date": "2023-08-09",
      "tags": [
        "mythology",
        "greek"
      ],
      "summary": "Greek mythology gave the Western world its gods, heroes, and monsters. This article introduces the stories that still echo through art and language today.",
      "body": "Few bodies of storytelling have shaped Western culture as deeply as Greek mythology. Its gods, heroes, and monsters have populated art, literature, and everyday language for thousands of years, and their names still label planets, brands, and constellations.\n\nThe Greeks imagined a universe that began in chaos and gradually took shape as the first divine beings emerged. From them came the Titans, and from the Titans came the Olympian gods who overthrew their parents and took command of the cosmos. This pattern of one generation supplanting the last runs through the mythology like a heartbeat.\n\nThe gods lived atop Mount Olympus and were strikingly human in temperament. They loved, quarrelled, schemed, and took revenge, meddling constantly in mortal affairs. Zeus ruled with his thunderbolt, Poseidon commanded the seas, and Hades governed the dead, while goddesses such as Athena, Hera, and Aphrodite wielded power in their own domains.\n\nAlongside the gods stood the heroes, mortals of extraordinary ability who often had a divine parent. Heracles performed his twelve labours, Perseus slew the gorgon Medusa, and Odysseus spent ten years struggling home from the Trojan War. Their adventures explored courage, cunning, and the limits of human ambition against the will of the gods.\n\nThese myths were never a fixed scripture. They varied from city to city and poet to poet, passed down orally before writers like Homer and Hesiod gave them lasting form. That flexibility is part of why they endure and adapt so easily. The GratisAPI Greek gods dataset at /api/greek-gods/index.json lists the major deities with their domains and symbols, a convenient starting point for study, games, or creative projects rooted in these timeless tales.",
      "word_count": 274,
      "reading_time_min": 1,
      "try_api": "greek-gods",
      "url": "https://gratisapi.com/api/articles/world-greek-mythology-primer"
    },
    {
      "id": "reference-unicode-vs-ascii",
      "title": "Unicode vs ASCII",
      "category": "Reference",
      "author": "The GratisAPI Team",
      "date": "2023-08-02",
      "tags": [
        "unicode",
        "ascii",
        "encoding"
      ],
      "summary": "Unicode extends the idea of ASCII to cover every writing system, using encodings like UTF-8.",
      "body": "ASCII was a triumph of its era, but it had a hard limit. With only 128 codes, it could represent English letters and basic symbols, yet it had no room for accented characters, let alone the thousands of symbols used in other writing systems. As computing went global, this became a serious problem.\n\nUnicode was created to solve it once and for all. Instead of 128 codes, Unicode aims to give every character in every human writing system a unique number, called a code point. It covers the Latin alphabet, Greek, Cyrillic, Arabic, Chinese, mathematical symbols, and even emoji. Crucially, the first 128 Unicode code points are identical to ASCII, so old text remains valid.\n\nThere is an important distinction between a code point and how it is stored. A code point is just a number; an encoding decides how that number becomes bytes. The most common encoding today is UTF-8, which is clever in a key way. For the original ASCII characters it uses a single byte identical to ASCII, and for other characters it uses two, three, or four bytes. This means a plain English document in UTF-8 is byte for byte the same as it was in ASCII.\n\nThis design is why UTF-8 won. It gave the world universal text without breaking the enormous body of existing ASCII data. Other encodings like UTF-16 exist, but UTF-8 dominates the web and most file formats.\n\nGratisAPI serves its data as UTF-8 JSON, and its ASCII dataset at /api/ascii/index.json shows the shared foundation both systems rest on. Studying that overlap makes the relationship concrete: ASCII is simply the first small neighborhood of the vast Unicode city.\n\nUnderstanding the difference resolves many everyday mysteries, such as why a document full of strange symbols usually means an encoding mismatch. The lesson is to always know which encoding your text uses, and to prefer UTF-8, which handles the whole world while staying compatible with the past.",
      "word_count": 323,
      "reading_time_min": 2,
      "try_api": "ascii",
      "url": "https://gratisapi.com/api/articles/reference-unicode-vs-ascii"
    },
    {
      "id": "science-dwarf-planets",
      "title": "Dwarf Planets",
      "category": "Science",
      "author": "The GratisAPI Team",
      "date": "2023-07-22",
      "tags": [
        "astronomy",
        "planets",
        "pluto"
      ],
      "summary": "Dwarf planets are round worlds that orbit the Sun but have not cleared their neighborhoods, a category that famously reclassified Pluto.",
      "body": "In 2006 the International Astronomical Union created a new category that changed how we think about the solar system: the dwarf planet. The most famous member is Pluto, which had been counted as the ninth planet for 76 years before its demotion.\n\nThe change came from a formal definition of what a planet is. To qualify as a full planet, a body must orbit the Sun, be massive enough for its own gravity to pull it into a round shape, and have cleared its orbital neighborhood of other objects. Dwarf planets meet the first two conditions but fail the third. They are round and orbit the Sun, but they share their orbital zone with many other bodies rather than dominating it.\n\nThere are currently five officially recognized dwarf planets. Ceres is the largest object in the asteroid belt between Mars and Jupiter. The other four lie in the distant, icy Kuiper Belt beyond Neptune: Pluto, Eris, Haumea, and Makemake. Eris is nearly the same size as Pluto and its discovery in 2005 directly triggered the debate over Pluto's status, since astronomers realized many similar worlds were waiting to be found.\n\nThese distant worlds are far from dull. The New Horizons spacecraft flew past Pluto in 2015 and revealed a stunningly complex surface with nitrogen ice glaciers, towering mountains of water ice, and a heart shaped plain. Haumea spins so fast that it has stretched into an elongated egg shape and even sports a ring.\n\nAstronomers expect the roster of dwarf planets to grow as surveys probe the outer solar system. You can find data on the planets that did make the full cut through the GratisAPI endpoint at /api/planets/index.json.",
      "word_count": 279,
      "reading_time_min": 1,
      "try_api": "planets",
      "url": "https://gratisapi.com/api/articles/science-dwarf-planets"
    },
    {
      "id": "world-five-oceans",
      "title": "The Five Oceans",
      "category": "Culture",
      "author": "The GratisAPI Team",
      "date": "2023-07-14",
      "tags": [
        "oceans",
        "geography"
      ],
      "summary": "One connected body of saltwater covers most of the planet, traditionally divided into five oceans. This article introduces the Pacific, Atlantic, Indian, Southern, and Arctic.",
      "body": "Water covers more than seventy percent of the Earth's surface, and almost all of it belongs to a single connected global ocean. For convenience we divide that ocean into five named parts: the Pacific, the Atlantic, the Indian, the Southern, and the Arctic.\n\nThe Pacific is by far the largest, so vast that all the continents could fit inside it with room to spare. It is also the deepest, home to the Mariana Trench, whose floor lies almost eleven kilometres below the surface. The Atlantic, second in size, separates the Americas from Europe and Africa and has carried much of the world's trade and migration.\n\nThe Indian Ocean, the third largest, is warm and monsoon driven, shaping the climate and history of the lands around its rim. The Southern Ocean encircles Antarctica and was only formally recognised by many authorities in recent decades; its powerful circumpolar current isolates the frozen continent and drives global weather. The Arctic, the smallest and shallowest, is capped by sea ice that is shrinking as the planet warms.\n\nThe oceans regulate everything. They absorb heat and carbon dioxide, generate much of the oxygen we breathe through microscopic plankton, and drive the weather through vast currents that redistribute warmth around the globe. Life almost certainly began in the sea, and the oceans still hold the majority of it.\n\nDespite their importance, the deep oceans remain less explored than the surface of the Moon. The GratisAPI oceans dataset at /api/oceans/index.json lists each ocean with its area and average depth, a compact reference for building maps, quizzes, and lessons about the waters that make our planet habitable.",
      "word_count": 269,
      "reading_time_min": 1,
      "try_api": "oceans",
      "url": "https://gratisapi.com/api/articles/world-five-oceans"
    },
    {
      "id": "reference-ascii-table",
      "title": "The ASCII Table",
      "category": "Reference",
      "author": "The GratisAPI Team",
      "date": "2023-07-10",
      "tags": [
        "ascii",
        "encoding",
        "text"
      ],
      "summary": "ASCII is the foundational character encoding that maps letters, digits, and symbols to numbers.",
      "body": "Computers store everything as numbers, including text. ASCII, the American Standard Code for Information Interchange, is the scheme that first gave every common English character an agreed number. Created in the early 1960s, it remains the bedrock beneath almost all modern text handling.\n\nASCII defines 128 codes, numbered 0 through 127. The first 32 are control codes, invisible signals such as newline, tab, and carriage return that once directed printers and terminals. The remaining codes cover printable characters: the space, punctuation, the digits 0 through 9, and the uppercase and lowercase English letters. So the letter A is 65, the letter a is 97, and the digit 0 is 48.\n\nThe layout of ASCII was designed with clever patterns. Uppercase and lowercase letters are separated by exactly 32, so you can switch case by adding or subtracting that value. The digits are arranged in order starting at 48, so converting a digit character to its numeric value is simple subtraction. These regularities made early text processing efficient on limited hardware.\n\nBecause ASCII only covers English, it could not represent accented letters or other scripts. That limitation led to many incompatible extensions and eventually to Unicode, which includes ASCII as its first 128 codes. This backward compatibility means every ASCII document is already valid modern text.\n\nGratisAPI provides the full table at /api/ascii/index.json. Each entry gives a code, the character it represents, and a description, which is useful for building encoders, teaching demos, or debugging tools that show the raw bytes behind text. Having the table as data saves you from retyping it.\n\nEven decades after its creation, ASCII quietly underlies programming languages, file formats, and network protocols. Learning the table gives you insight into how text truly works inside a computer, and it makes many puzzling encoding problems suddenly clear.",
      "word_count": 300,
      "reading_time_min": 2,
      "try_api": "ascii",
      "url": "https://gratisapi.com/api/articles/reference-ascii-table"
    },
    {
      "id": "howto-python-requests",
      "title": "Fetching GratisAPI with Python's requests Library",
      "category": "Tutorials",
      "author": "The GratisAPI Team",
      "date": "2023-07-08",
      "tags": [
        "python",
        "requests",
        "http"
      ],
      "summary": "Retrieve and parse GratisAPI endpoints in Python using the popular requests library.",
      "body": "The requests library is the most common way to make HTTP calls in Python, and it works seamlessly with GratisAPI. Because every endpoint is a static JSON file with no authentication, a single call gets you a full dataset.\n\nInstall the library with pip install requests, then fetch and parse an endpoint:\n\nimport requests\n\nurl = \"https://gratisapi.com/api/elements/index.json\"\nresponse = requests.get(url, timeout=10)\nresponse.raise_for_status()\ndata = response.json()\n\nprint(f\"Loaded {data['count']} elements\")\nfor element in data[\"elements\"]:\n    print(element[\"name\"], element[\"symbol\"])\n\nThe raise_for_status call is important. Unlike JavaScript's fetch, requests does not automatically raise on a 404 or 500, so calling raise_for_status turns any error status into a Python exception you can catch. The .json() method parses the response body into ordinary Python dictionaries and lists.\n\nSetting a timeout is good practice for any network call so your script does not hang indefinitely if the connection stalls. Wrap the request in a try/except around requests.exceptions.RequestException to handle both connection failures and bad statuses in one place.\n\nBecause GratisAPI ships complete collections, you generally make one request and then work with the data locally. This suits Python's data tooling well. You can feed the list of records straight into a loop, into a comprehension for filtering, or into a library like pandas for analysis. There is no pagination to chase and no token to refresh, so a script can go from zero to usable data in about five lines. For repeated runs, consider caching the response to a local file, since the static endpoints only change when the project is redeployed.",
      "word_count": 253,
      "reading_time_min": 1,
      "try_api": "elements",
      "url": "https://gratisapi.com/api/articles/howto-python-requests"
    },
    {
      "id": "freedom-what-copyleft-is",
      "title": "What Copyleft Is",
      "category": "Philosophy",
      "author": "The GratisAPI Team",
      "date": "2023-07-03",
      "tags": [
        "copyleft",
        "licensing",
        "gpl"
      ],
      "summary": "Copyleft is a clever use of copyright law that keeps software free by requiring derived works to carry the same freedoms forward.",
      "body": "Copyleft is a strategy for keeping software free by turning copyright law against its usual purpose. Ordinarily, copyright lets an author restrict copying and modification. Copyleft uses that same legal power to guarantee the opposite: that a work, and every version derived from it, remains free for all users.\n\nThe mechanism is a license condition. A copyleft license grants everyone the four freedoms to use, study, modify, and share the software, but attaches one requirement. If you distribute the software, or a modified version of it, you must pass along those same freedoms under the same license. You may not take the code, improve it, and lock the result away as proprietary.\n\nThe name is a play on copyright, suggesting a mirror image. Where copyright typically hoards rights for the author, copyleft spreads them to everyone and uses the law to keep them spread. It is sometimes described as a viral or share-alike condition, because the freedom propagates to derived works.\n\nCopyleft contrasts with permissive licensing. A permissive license, such as the MIT or BSD license, grants the freedoms but does not require them to be preserved downstream. Someone can take permissively licensed code and incorporate it into a closed product. Copyleft closes that path, ensuring that what starts free stays free.\n\nThere are degrees of copyleft. Strong copyleft, as in the GPL, extends to an entire combined work. Weak copyleft, as in the Lesser GPL, applies more narrowly, allowing linking with proprietary code under conditions. Each represents a different balance between spreading freedom and easing adoption.\n\nGratisAPI is released under the GPL, a strong copyleft license. That choice means our data tools cannot be quietly absorbed into a closed product. Whatever is built on them must keep the freedoms alive, which is exactly the point of copyleft.",
      "word_count": 298,
      "reading_time_min": 1,
      "try_api": "cocktails",
      "url": "https://gratisapi.com/api/articles/freedom-what-copyleft-is"
    },
    {
      "id": "world-seven-continents",
      "title": "The Seven Continents",
      "category": "Culture",
      "author": "The GratisAPI Team",
      "date": "2023-06-22",
      "tags": [
        "continents",
        "geography"
      ],
      "summary": "Most schools teach seven continents, from vast Asia to frozen Antarctica. This article explains what a continent is and why the count varies.",
      "body": "The world is commonly divided into seven continents: Asia, Africa, North America, South America, Antarctica, Europe, and Australia. Together they hold every mountain, desert, and city on the planet, ordered here from largest to smallest.\n\nAsia is the giant, covering about a third of the land surface and home to more than half of humanity. Africa follows, straddling the equator with the greatest spread of climates and an unmatched diversity of wildlife. The Americas stretch nearly from pole to pole, while Antarctica sits frozen at the bottom of the world, a continent with no permanent human population.\n\nThe number seven is not universal. Some traditions combine Europe and Asia into a single landmass called Eurasia, since no ocean separates them, giving six continents. Others merge the two Americas, also yielding six but by a different route. A few models count only four or five. The disagreements arise because a continent is partly a geographical fact and partly a cultural convention.\n\nGeologists take a different view again, thinking in terms of tectonic plates and continental shelves rather than the shapes we see on maps. By that reasoning some argue for a hidden eighth continent, Zealandia, largely submerged beneath the ocean around New Zealand.\n\nContinents drift slowly over millions of years, once joined in a single supercontinent called Pangaea and destined to reassemble in the distant future. For everyday purposes, though, the familiar seven remain the standard. The GratisAPI continents dataset at /api/continents/index.json lists each one with its area and population, giving you a clean starting point for maps, quizzes, and lessons about how we carve up the world.",
      "word_count": 267,
      "reading_time_min": 1,
      "try_api": "continents",
      "url": "https://gratisapi.com/api/articles/world-seven-continents"
    },
    {
      "id": "reference-well-known-ports",
      "title": "Well Known Network Ports",
      "category": "Reference",
      "author": "The GratisAPI Team",
      "date": "2023-06-19",
      "tags": [
        "networking",
        "ports",
        "tcp"
      ],
      "summary": "Well known ports are reserved numbers that identify common network services like web and email.",
      "body": "When two computers talk over a network, an address alone is not enough. A single machine may run many services at once, so each connection also names a port, a number that identifies which service the traffic is meant for. Ports let one server host a website, an email service, and a database without confusion.\n\nPort numbers range from 0 to 65535, and they are divided into groups. The lowest range, from 0 to 1023, holds the well known ports, reserved for common services by a central authority. Above that sits a range of registered ports assigned to specific applications, and the highest range is left free for temporary connections that clients create on the fly.\n\nMany well known ports are worth memorizing. Web traffic uses port 80 for plain HTTP and port 443 for secure HTTPS. Email relies on port 25 for sending mail and other numbers for retrieving it. Secure remote login over SSH uses port 22, file transfer over FTP uses port 21, and domain name lookups use port 53. Knowing these makes reading network configuration far easier.\n\nPorts combine with the transport protocol to form a complete endpoint. Most services run over TCP, which provides reliable ordered delivery, while some real time services use UDP, which is faster but less careful. The same number can mean different things on TCP and UDP, so both matter.\n\nGratisAPI offers this reference at /api/tcp-ports/index.json. Each entry lists a port number, the service that uses it, and a short description, which is useful for building firewall tools, teaching material, or configuration checkers. Rather than searching scattered documentation, you can pull the whole table in one request.\n\nUnderstanding ports demystifies a great deal of networking. Once you know that an address plus a port names a specific service, concepts like firewalls, forwarding, and secure connections become much easier to reason about.",
      "word_count": 310,
      "reading_time_min": 2,
      "try_api": "tcp-ports",
      "url": "https://gratisapi.com/api/articles/reference-well-known-ports"
    },
    {
      "id": "science-tour-of-the-solar-system",
      "title": "A Tour of the Solar System",
      "category": "Science",
      "author": "The GratisAPI Team",
      "date": "2023-06-18",
      "tags": [
        "astronomy",
        "planets",
        "solar-system"
      ],
      "summary": "A journey outward from the Sun reveals eight distinct planets, from scorched rocky worlds to giant balls of gas and ice.",
      "body": "Our solar system is a family of eight planets orbiting a single ordinary star, the Sun. Taking a tour outward from the center reveals just how varied these worlds are.\n\nThe inner four planets are small and rocky. Mercury, closest to the Sun, is a cratered ball of rock with almost no atmosphere and wild temperature swings. Venus, shrouded in thick clouds of carbon dioxide, is the hottest planet of all thanks to a runaway greenhouse effect. Earth, our blue home, is the only known world with liquid water on its surface and abundant life. Mars, the red planet, is a cold desert that once had rivers and lakes and remains a prime target in the search for past life.\n\nBeyond Mars lies the asteroid belt, and then the character of the solar system changes dramatically. The outer four are giant planets. Jupiter is a colossus of gas so massive it could swallow all the other planets, famous for its Great Red Spot, a storm larger than Earth. Saturn, adorned with spectacular rings of ice and rock, is the jewel of the solar system. Uranus and Neptune are ice giants, frigid blue worlds rich in water, ammonia, and methane, with Uranus tipped so far over that it rolls around the Sun on its side.\n\nThe planets differ enormously in size, composition, and the number of moons they host. Distances are vast, measured in hundreds of millions of kilometers, and light from the Sun takes hours to reach the outer worlds.\n\nYou can compare orbital periods, diameters, and other statistics for all eight planets through the GratisAPI endpoint at /api/planets/index.json.",
      "word_count": 269,
      "reading_time_min": 1,
      "try_api": "planets",
      "url": "https://gratisapi.com/api/articles/science-tour-of-the-solar-system"
    },
    {
      "id": "howto-nodejs",
      "title": "Calling GratisAPI from Node.js",
      "category": "Tutorials",
      "author": "The GratisAPI Team",
      "date": "2023-06-11",
      "tags": [
        "nodejs",
        "javascript",
        "server"
      ],
      "summary": "Use the native fetch available in modern Node.js to retrieve GratisAPI data on the server.",
      "body": "Modern versions of Node.js, from version 18 onward, ship with a global fetch function, so calling GratisAPI on the server needs no dependencies at all. The code looks almost identical to browser code.\n\nCreate a script and await a fetch against any endpoint:\n\nasync function main() {\n  const res = await fetch(\"https://gratisapi.com/api/countries/index.json\");\n  if (!res.ok) throw new Error(\"Request failed: \" + res.status);\n  const data = await res.json();\n  console.log(`Loaded ${data.count} countries`);\n}\n\nmain().catch(console.error);\n\nRun it with node script.mjs. If you are on an older Node release without global fetch, either upgrade or install a small library such as node-fetch and import it at the top.\n\nServer-side use unlocks a few patterns the browser cannot easily do. You can fetch an endpoint, transform or enrich the data, and expose your own tailored API to your front end. You can run a scheduled job that pulls a GratisAPI collection and writes it to your database as seed data. You can also cache responses on disk, which is especially sensible here because the files are static and only change when the project is redeployed.\n\nOne genuine advantage of server-side fetching is avoiding cross-origin concerns entirely. Browsers enforce CORS, but a Node process does not, so you have full freedom over how you request and combine endpoints. Because GratisAPI imposes no rate limits and no keys, you can call it as often as your job requires. Just be a good citizen and cache when you can, since re-downloading an unchanged static file on every request wastes bandwidth for no benefit. A simple in-memory Map keyed by URL, or a timed cache, is usually all you need.",
      "word_count": 270,
      "reading_time_min": 1,
      "try_api": "countries",
      "url": "https://gratisapi.com/api/articles/howto-nodejs"
    },
    {
      "id": "freedom-the-gnu-project",
      "title": "The GNU Project",
      "category": "Philosophy",
      "author": "The GratisAPI Team",
      "date": "2023-06-06",
      "tags": [
        "gnu",
        "history",
        "operating-system"
      ],
      "summary": "Launched in 1983, the GNU Project set out to build a complete free operating system and produced much of the software the world now runs.",
      "body": "The GNU Project is a collaborative effort, announced by Richard Stallman in 1983, to develop a complete operating system that would be entirely free software. The name is a recursive acronym meaning GNU's Not Unix, signaling that GNU would be compatible with the widely used Unix system while sharing none of its proprietary code.\n\nBuilding an operating system is enormous work, and the project proceeded piece by piece. Over the years GNU developers produced a vast collection of essential components: the GCC compiler, the GNU C Library, the Bash shell, the Emacs editor, the coreutils, and many more. Much of this software became foundational infrastructure used far beyond the free software community.\n\nOne major piece proved stubborn. The kernel, the central component that manages hardware and processes, was slow to mature under the GNU Hurd effort. In 1991 Linus Torvalds released the Linux kernel, which was soon combined with the GNU system components to form a complete, working, free operating system.\n\nThis history is the source of a long-running naming debate. The FSF and the GNU Project argue that the combined system should be called GNU/Linux to credit the GNU components, while much of the public simply says Linux. The dispute reflects a genuine question of attribution rather than mere pedantry.\n\nBeyond code, the GNU Project produced enduring institutions and ideas: the General Public License, the free software definition, and a philosophy that continues to shape debates about technology and rights.\n\nGratisAPI stands on this inheritance. The tools we build with, the licenses we use, and the very idea that software should respect its users all trace back in part to the ambitious decision, made in 1983, to build an operating system that would belong to everyone.",
      "word_count": 287,
      "reading_time_min": 1,
      "try_api": "animals",
      "url": "https://gratisapi.com/api/articles/freedom-the-gnu-project"
    },
    {
      "id": "reference-mime-types",
      "title": "MIME Types Explained",
      "category": "Reference",
      "author": "The GratisAPI Team",
      "date": "2023-05-28",
      "tags": [
        "mime",
        "http",
        "content-type"
      ],
      "summary": "MIME types label the kind of content in a file or response so software knows how to handle it.",
      "body": "A MIME type is a short label that tells software what kind of data it is looking at. The name comes from Multipurpose Internet Mail Extensions, a standard first created for email attachments, but the labels are now used everywhere, especially on the web.\n\nA MIME type has two parts separated by a slash. The first part is a general category, such as text, image, audio, or application. The second part is the specific format within that category. So plain text is text and plain, a JSON document is application and json, a PNG image is image and png, and an HTML page is text and html. This simple two part scheme can name thousands of formats.\n\nOn the web, MIME types travel in a header called Content-Type. When a server sends a response, it includes this header so the browser knows whether to render a page, show an image, or download a file. If the label is wrong, the browser may misinterpret the content, showing raw code instead of a picture or refusing to run a script. Getting the type right is essential for correct behavior.\n\nMIME types also drive content negotiation, where a client uses an Accept header to say which formats it can handle and the server responds with the best match. This lets one address serve HTML to a browser and JSON to a program.\n\nGratisAPI provides a reference list at /api/mime-types/index.json. Each entry pairs a type with a common file extension and a short description, which is handy for building file upload validators, download tools, or lookup features. The API itself is served with the application and json type so clients parse it correctly.\n\nUnderstanding MIME types helps explain many everyday puzzles, from why a download opens in the wrong program to why a browser refuses to display a file. The label is small, but it shapes how every piece of content on the web is treated.",
      "word_count": 322,
      "reading_time_min": 2,
      "try_api": "mime-types",
      "url": "https://gratisapi.com/api/articles/reference-mime-types"
    },
    {
      "id": "science-how-stars-are-classified",
      "title": "How Stars Are Classified",
      "category": "Science",
      "author": "The GratisAPI Team",
      "date": "2023-05-20",
      "tags": [
        "astronomy",
        "stars",
        "spectroscopy"
      ],
      "summary": "Astronomers sort stars by their color and temperature using a lettered spectral system, a scheme that reveals a star's size, age, and fate.",
      "body": "Stars may look like uniform white dots, but they come in a vast range of colors, temperatures, and sizes. Astronomers make sense of this diversity with a classification system based mainly on a star's surface temperature, which betrays itself through the star's color and the pattern of lines in its spectrum.\n\nThe primary scheme uses seven main letters: O, B, A, F, G, K, and M. This sequence runs from the hottest stars to the coolest. O type stars are searing blue giants exceeding thirty thousand degrees, while M type stars are cool red dwarfs below four thousand. Generations of students remember the order with the mnemonic Oh Be A Fine Guy or Girl, Kiss Me. Each letter is further divided by a number from zero to nine for finer gradations. Our own Sun is a G type star, a modest yellow dwarf with a surface near five thousand five hundred degrees.\n\nTemperature alone does not tell the whole story. A second dimension, called luminosity class, distinguishes tiny dwarfs from bloated supergiants that can be hundreds of times the diameter of the Sun. Combining the two, the Sun is classified as G2V, where the V marks it as an ordinary main sequence star fusing hydrogen in its core.\n\nWhen astronomers plot temperature against brightness for many stars, a striking pattern appears, known as the Hertzsprung Russell diagram. Most stars fall along a diagonal band called the main sequence, with giants and white dwarfs occupying separate regions. A star's position on this diagram reveals its stage of life.\n\nYou can explore data on notable stars, including their spectral types and distances, through the GratisAPI endpoint at /api/stars/index.json.",
      "word_count": 276,
      "reading_time_min": 1,
      "try_api": "stars",
      "url": "https://gratisapi.com/api/articles/science-how-stars-are-classified"
    },
    {
      "id": "world-longest-rivers",
      "title": "The Longest Rivers",
      "category": "Culture",
      "author": "The GratisAPI Team",
      "date": "2023-05-18",
      "tags": [
        "rivers",
        "geography"
      ],
      "summary": "The Nile and the Amazon vie for the title of longest river, each stretching more than 6,000 kilometres. This article explores the world's great waterways.",
      "body": "Rivers are the arteries of the continents, carrying water, sediment, and life from mountain sources to the sea. The longest of them span thousands of kilometres and drain areas larger than many countries.\n\nThe title of longest river is genuinely contested. The Nile in Africa is traditionally cited at around 6,650 kilometres, flowing north through eleven countries to the Mediterranean. The Amazon in South America is close behind and, by some measurements that trace its most distant source, may actually be longer. The debate hinges on where exactly each river begins, which is harder to pin down than it sounds.\n\nWhat is not in dispute is the Amazon's dominance by volume. It carries more water than the next several largest rivers combined, discharging so much freshwater that it noticeably dilutes the ocean far offshore. Its basin holds the largest rainforest on Earth and an astonishing share of the planet's biodiversity.\n\nOther great rivers have shaped human history just as profoundly. The Yangtze and Yellow rivers cradled Chinese civilisation, the Tigris and Euphrates gave rise to the first cities of Mesopotamia, and the Mississippi drains the heart of North America. Wherever rivers flow reliably, people have gathered to farm, trade, and build.\n\nRivers face growing pressure from dams, pollution, and a changing climate that alters the snow and rain that feed them. Understanding them starts with good data. The GratisAPI rivers dataset at /api/rivers/index.json lists major rivers with their lengths and the continents they cross, a handy foundation for maps, quizzes, and lessons about the waterways that sustain us.",
      "word_count": 258,
      "reading_time_min": 1,
      "try_api": "rivers",
      "url": "https://gratisapi.com/api/articles/world-longest-rivers"
    },
    {
      "id": "howto-vue-app",
      "title": "Using GratisAPI in a Vue App",
      "category": "Tutorials",
      "author": "The GratisAPI Team",
      "date": "2023-05-18",
      "tags": [
        "vue",
        "javascript",
        "composition-api"
      ],
      "summary": "Load GratisAPI data into a Vue component using the Composition API and reactive refs.",
      "body": "Vue's reactivity system pairs nicely with GratisAPI's static JSON files. With the Composition API you fetch the data in the setup function, store it in a ref, and let Vue update the template automatically when the value arrives.\n\nHere is a single-file component that loads the colors collection. The onMounted lifecycle hook triggers the request after the component is mounted, and the ref keeps the result reactive:\n\n<script setup>\nimport { ref, onMounted } from \"vue\";\n\nconst colors = ref([]);\nconst loading = ref(true);\n\nonMounted(async () => {\n  try {\n    const res = await fetch(\"https://gratisapi.com/api/colors/index.json\");\n    const data = await res.json();\n    colors.value = data.colors;\n  } finally {\n    loading.value = false;\n  }\n});\n</script>\n\n<template>\n  <p v-if=\"loading\">Loading...</p>\n  <ul v-else>\n    <li v-for=\"c in colors\" :key=\"c.id\">{{ c.name }} - {{ c.hex }}</li>\n  </ul>\n</template>\n\nThe v-for directive iterates the array, and binding :key to each record's id helps Vue track items efficiently. The v-if and v-else pair swaps a loading message for the list once data is ready.\n\nBecause the endpoint returns the whole collection at once, you can build computed properties to filter or sort without touching the network again. For example, a computed value could return only colors whose name matches a search box. If you use Pinia for state management, move the fetch into a store action so multiple components can share the same cached data. The key point is that GratisAPI asks nothing special of Vue: no keys, no auth, just a fetch of a static file that slots directly into the framework's reactive model.",
      "word_count": 255,
      "reading_time_min": 1,
      "try_api": "colors",
      "url": "https://gratisapi.com/api/articles/howto-vue-app"
    },
    {
      "id": "freedom-four-essential-freedoms",
      "title": "The Four Essential Software Freedoms",
      "category": "Philosophy",
      "author": "The GratisAPI Team",
      "date": "2023-05-11",
      "tags": [
        "four-freedoms",
        "definition",
        "libre"
      ],
      "summary": "The free software definition rests on four freedoms, numbered zero through three, that together determine whether a program respects its users.",
      "body": "The Free Software Foundation defines software as free when it grants its users four essential freedoms. A program that provides all four is free, or libre; a program that withholds any of them is proprietary in at least that respect. The freedoms are conventionally numbered starting from zero, a small nod to programmers who count that way.\n\nFreedom zero is the freedom to run the program as you wish, for any purpose. There are no restrictions on who may use the software or what they may use it for. A license that forbids commercial use, or use by particular groups, violates this freedom.\n\nFreedom one is the freedom to study how the program works and to change it so it does your computing as you wish. This freedom requires access to the source code, since studying and modifying a program without its source is impractical. Without freedom one, users are dependent on the original developer for every change.\n\nFreedom two is the freedom to redistribute copies so you can help others. You may share the program with your neighbor, your community, or the world, at no charge or for a price, without asking permission.\n\nFreedom three is the freedom to distribute copies of your modified versions to others. By doing this you give the whole community a chance to benefit from your changes. Like freedom one, it requires access to source code.\n\nTogether these freedoms describe genuine control over one's computing. Freedoms zero and two concern using and sharing the program as it is; freedoms one and three concern understanding and improving it. Notably, none of them mentions price, which is why free software can be sold.\n\nGratisAPI is built to honor all four. The data and code are open, inspectable, modifiable, and freely redistributable, so the freedoms are not slogans but properties you can exercise today.",
      "word_count": 307,
      "reading_time_min": 2,
      "try_api": "cocktails",
      "url": "https://gratisapi.com/api/articles/freedom-four-essential-freedoms"
    },
    {
      "id": "reference-http-methods",
      "title": "HTTP Methods Explained",
      "category": "Reference",
      "author": "The GratisAPI Team",
      "date": "2023-05-03",
      "tags": [
        "http",
        "methods",
        "rest"
      ],
      "summary": "HTTP methods are the verbs of the web, describing what action a request intends to perform.",
      "body": "When a client makes an HTTP request, it does more than name an address. It also states an intention using an HTTP method, sometimes called a verb. The method tells the server what kind of action the client wants to perform on the resource at that address.\n\nThe most common method is GET, which asks the server to return a resource without changing anything. GET is the workhorse of the web; every time you load a page or fetch data, you are sending a GET. Because it only reads, a GET can be repeated safely and its results can be cached.\n\nPOST is used to send data to the server, often to create something new or trigger processing. Unlike GET, a POST may change the state of the server, so repeating it can have real effects. PUT replaces a resource entirely with the data you send, while PATCH updates only part of it. DELETE, as the name suggests, asks the server to remove a resource.\n\nTwo important ideas describe how these methods behave. A method is safe if it does not modify anything, which applies to GET and HEAD. A method is idempotent if making the same request several times has the same effect as making it once; GET, PUT, and DELETE are idempotent, while POST generally is not. These properties guide how clients and caches can treat requests.\n\nGratisAPI publishes the method list as data at /api/http-methods/index.json. Each entry names a method and describes its purpose and properties, which is useful for building documentation or teaching tools. Because GratisAPI serves static data, every endpoint responds to GET, matching the read only nature of the project.\n\nChoosing the right method is central to designing a clean REST API. Using GET for reads, POST for creation, and DELETE for removal makes your interface predictable, and predictability is what lets other developers use your service with confidence.",
      "word_count": 315,
      "reading_time_min": 2,
      "try_api": "http-methods",
      "url": "https://gratisapi.com/api/articles/reference-http-methods"
    },
    {
      "id": "howto-react-app",
      "title": "Using GratisAPI in a React App",
      "category": "Tutorials",
      "author": "The GratisAPI Team",
      "date": "2023-04-21",
      "tags": [
        "react",
        "javascript",
        "hooks"
      ],
      "summary": "Fetch and render GratisAPI collections inside a React component using useEffect and useState.",
      "body": "React makes consuming GratisAPI straightforward because the data is static and predictable. The standard approach is to fetch once when a component mounts, store the result in state, and render from that state.\n\nUse the useState hook to hold the data, a loading flag, and any error. Use the useEffect hook to perform the fetch after the first render. Pass an empty dependency array so the request runs only once:\n\nimport { useState, useEffect } from \"react\";\n\nfunction Quotes() {\n  const [quotes, setQuotes] = useState([]);\n  const [loading, setLoading] = useState(true);\n\n  useEffect(() => {\n    fetch(\"https://gratisapi.com/api/quotes/index.json\")\n      .then(r => r.json())\n      .then(data => { setQuotes(data.quotes); setLoading(false); })\n      .catch(() => setLoading(false));\n  }, []);\n\n  if (loading) return <p>Loading...</p>;\n  return <ul>{quotes.map(q => <li key={q.id}>{q.text}</li>)}</ul>;\n}\n\nA couple of details make this robust. Always provide a stable key prop, and GratisAPI records include an id field that is ideal for this. Keep a loading state so the interface does not flash empty content while the request is in flight, and handle errors so a network hiccup does not leave the user staring at a blank screen.\n\nBecause GratisAPI returns entire datasets in a single file, you rarely need to re-fetch. Load the collection once, then filter, sort, or paginate in memory using ordinary array methods and additional state. For larger apps you might move the fetch into a custom hook such as useGratisAPI, or into a data library like React Query that adds caching and revalidation for free. Either way, the underlying request stays a simple, keyless GET against a static JSON file.",
      "word_count": 255,
      "reading_time_min": 1,
      "try_api": "quotes",
      "url": "https://gratisapi.com/api/articles/howto-react-app"
    },
    {
      "id": "freedom-free-software-foundation",
      "title": "The Free Software Foundation",
      "category": "Philosophy",
      "author": "The GratisAPI Team",
      "date": "2023-04-19",
      "tags": [
        "fsf",
        "organization",
        "history"
      ],
      "summary": "Founded in 1985, the Free Software Foundation is the nonprofit that stewards the ideals and legal tools of the free software movement.",
      "body": "The Free Software Foundation, or FSF, is a nonprofit organization founded by Richard Stallman in 1985 to support the free software movement. Its early purpose was practical: to fund and organize development of the GNU system by employing programmers and accepting donations. Over time its role broadened into advocacy, education, and stewardship of the movement's legal and philosophical foundations.\n\nOne of the FSF's most consequential contributions is the family of GNU licenses. The organization publishes and maintains the GNU General Public License, the Lesser General Public License, and the Affero General Public License, along with the GNU Free Documentation License. These licenses turn the abstract idea of software freedom into enforceable legal terms that developers can attach to their work.\n\nThe FSF also maintains a definition of free software built around four essential freedoms, and it curates a list of licenses it considers compatible with those freedoms. Its sister organization in Europe, the Free Software Foundation Europe, pursues related goals in a different legal and cultural context.\n\nBeyond licensing, the FSF runs public campaigns on issues such as digital restrictions management, which it opposes, and the promotion of fully free operating system distributions. It maintains the Free Software Directory and recognizes hardware and software that respect user freedom through its certification programs.\n\nThe organization is deliberately uncompromising. Where others accept partial openness, the FSF tends to insist on the complete set of freedoms, which sometimes places it at odds with more pragmatic parts of the software world.\n\nProjects like GratisAPI benefit directly from the FSF's work. The GPL license under which our code is released, and the very vocabulary of gratis and libre we use to describe ourselves, are products of the intellectual and legal groundwork the Foundation laid.",
      "word_count": 289,
      "reading_time_min": 1,
      "try_api": "quotes",
      "url": "https://gratisapi.com/api/articles/freedom-free-software-foundation"
    },
    {
      "id": "reference-story-of-the-404",
      "title": "The Story of the 404",
      "category": "Reference",
      "author": "The GratisAPI Team",
      "date": "2023-04-12",
      "tags": [
        "http",
        "404",
        "history"
      ],
      "summary": "The 404 Not Found status has become the most recognizable error on the web. Here is where it came from.",
      "body": "Of all the numbers on the web, 404 is the one that escaped into everyday language. People say a topic is a 404 when it cannot be found, even far away from any computer. The code has a specific technical meaning, but its cultural life is far larger.\n\nTechnically, 404 belongs to the family of client error codes in the 400 range. It means the server understood the request perfectly well but could not find anything at the requested address. Importantly, 404 does not say whether the absence is temporary or permanent; there is a separate code, 410 Gone, for resources that have been deliberately removed for good.\n\nA popular myth claims the number comes from a room 404 at a research center where the early web was born, supposedly the office where a missing file would have lived. It is a charming story, but there is no real evidence for it. The truth is more ordinary: 404 simply follows the numbering scheme laid out in the early HTTP specifications, where the second and third digits distinguish specific errors within the 400 group.\n\nWhat makes 404 special is how visible it is. Almost every other error is handled quietly by software, but a 404 is often shown directly to a person who clicked a broken link. Over time, designers turned these pages into playful, branded experiences, which cemented the number in popular memory.\n\nYou can find 404 alongside its siblings in the GratisAPI status dataset at /api/http-status/index.json, complete with its official name and description. Studying it is a small lesson in how a dry technical detail can take on a life of its own. The next time you hit a 404, remember that you are looking at the most famous three digits the web ever produced.",
      "word_count": 296,
      "reading_time_min": 1,
      "try_api": "http-status",
      "url": "https://gratisapi.com/api/articles/reference-story-of-the-404"
    },
    {
      "id": "world-tallest-mountains",
      "title": "The Tallest Mountains on Earth",
      "category": "Culture",
      "author": "The GratisAPI Team",
      "date": "2023-04-05",
      "tags": [
        "mountains",
        "geography"
      ],
      "summary": "Earth's highest peaks all rise in Asia, crowned by Mount Everest at 8,849 metres. This article surveys the giants of the Himalayas and beyond.",
      "body": "The highest mountains on Earth are so tall that their summits reach into the thin air where jet aircraft cruise. All fourteen peaks above 8,000 metres, the so called eight thousanders, are found in Asia, spread across the Himalaya and Karakoram ranges.\n\nMount Everest, straddling the border of Nepal and Tibet, is the highest of them all at 8,849 metres above sea level. It was first climbed in 1953 by Edmund Hillary and Tenzing Norgay, and it remains the ultimate goal for high altitude mountaineers despite its crowds and dangers. K2, on the border of Pakistan and China, is second at 8,611 metres and is considered far more difficult and deadly to climb.\n\nHeight above sea level is only one way to measure a mountain. Measured from base to summit, Mauna Kea in Hawaii is taller than Everest, though most of it lies underwater. Measured by distance from the centre of the Earth, the peak of Chimborazo in Ecuador wins, because the planet bulges at the equator. Each measure tells a different but valid story.\n\nMountains shape climate, culture, and history. They wring rain from passing clouds, feed the great rivers that sustain billions of people downstream, and form natural borders that have divided empires. Many are sacred to the communities living in their shadow.\n\nThe GratisAPI mountains dataset at /api/mountains/index.json lists notable peaks with their heights and locations, making it easy to build comparison charts, quizzes, or geography lessons. Whether you are curious about the eight thousanders or the highest point on your own continent, a clean dataset is the fastest way to start exploring.",
      "word_count": 266,
      "reading_time_min": 1,
      "try_api": "mountains",
      "url": "https://gratisapi.com/api/articles/world-tallest-mountains"
    },
    {
      "id": "science-88-constellations",
      "title": "The 88 Constellations",
      "category": "Science",
      "author": "The GratisAPI Team",
      "date": "2023-04-05",
      "tags": [
        "astronomy",
        "constellations",
        "stars"
      ],
      "summary": "The sky is officially divided into 88 constellations, a map that astronomers use to organize and locate everything in the heavens.",
      "body": "When you look up at a clear night sky, the scattered points of light seem random. For thousands of years, though, human cultures have grouped those points into pictures, and today astronomers recognize exactly 88 official constellations that together cover the entire celestial sphere.\n\nMany of the constellations we use come from ancient Greece and were catalogued by the astronomer Ptolemy nearly two thousand years ago. These include the zodiac figures such as Leo the lion and Scorpius the scorpion, as well as prominent groups like Orion the hunter and Ursa Major, the great bear that contains the Big Dipper. Other constellations, especially those in the far southern sky invisible from Europe, were added by explorers and astronomers in the sixteenth through eighteenth centuries and bear names like Telescopium and Microscopium.\n\nIn 1922 the International Astronomical Union formally adopted the list of 88, and a few years later fixed precise boundaries between them. This turned the constellations from loose pictures into an exact coordinate grid. Every star, galaxy, and comet now falls within the borders of a specific constellation, much as every town falls within a country.\n\nIt is worth remembering that the stars in a constellation are almost never physically related. They can lie at wildly different distances, appearing close only because they happen to fall along the same line of sight from Earth. The pattern is a trick of perspective, not a true cluster.\n\nConstellations remain a practical tool for navigating the sky. You can browse the full list of all 88, along with details about each, through the GratisAPI endpoint at /api/constellations/index.json.",
      "word_count": 265,
      "reading_time_min": 1,
      "try_api": "constellations",
      "url": "https://gratisapi.com/api/articles/science-88-constellations"
    },
    {
      "id": "freedom-stallman-and-the-movement",
      "title": "Richard Stallman and the Free Software Movement",
      "category": "Philosophy",
      "author": "The GratisAPI Team",
      "date": "2023-03-27",
      "tags": [
        "stallman",
        "history",
        "free-software"
      ],
      "summary": "Richard Stallman launched the free software movement in the 1980s, arguing that users deserve control over the software they run.",
      "body": "Richard Stallman is the programmer and activist who gave the free software movement its founding ideas. Working at the MIT Artificial Intelligence Laboratory in the 1970s and early 1980s, he grew frustrated as the collaborative, sharing culture of early computing gave way to proprietary licensing that forbade programmers from studying or improving the tools they used.\n\nA frequently told anecdote involves a laser printer whose controlling software Stallman was not permitted to modify to add a useful feature. Whatever the exact details, the broader pattern was clear to him: software was being locked away, and the people who depended on it were losing the ability to understand and fix their own tools.\n\nIn 1983 Stallman announced the GNU Project, an effort to build a complete operating system that users would be free to run, study, modify, and share. In 1985 he founded the Free Software Foundation to support that work and to advance software freedom more broadly. He also wrote foundational software, including much of the GNU toolchain, and drafted the GNU General Public License.\n\nStallman's central argument is ethical rather than merely practical. He holds that proprietary software gives its owners unjust power over users, and that people have a right to control the programs that shape their lives. This framing distinguishes the free software movement from later movements that emphasize development efficiency.\n\nStallman has also been a controversial figure whose public statements on various topics have drawn significant criticism and led to disputes within the community he helped create. Acknowledging this is part of a fair account.\n\nWhatever one makes of the man, the ideas he articulated, that software should respect its users' freedom, reshaped computing and made projects like GratisAPI possible.",
      "word_count": 284,
      "reading_time_min": 1,
      "try_api": "countries",
      "url": "https://gratisapi.com/api/articles/freedom-stallman-and-the-movement"
    },
    {
      "id": "reference-http-status-codes",
      "title": "HTTP Status Codes Explained",
      "category": "Reference",
      "author": "The GratisAPI Team",
      "date": "2023-03-20",
      "tags": [
        "http",
        "status-codes",
        "web"
      ],
      "summary": "HTTP status codes are three digit numbers that tell a client how a request turned out.",
      "body": "Every time a browser or program makes an HTTP request, the server answers with a three digit status code. This small number is a compact summary of what happened, and learning to read it is one of the most useful skills in web development.\n\nStatus codes are grouped into five families by their first digit. Codes in the 100 range are informational and rarely seen directly. The 200 range means success; 200 itself means the request worked and 201 means something new was created. The 300 range is about redirection, telling the client the resource lives elsewhere. The 400 range signals a client error, meaning the request was somehow wrong, while the 500 range signals a server error, meaning the server failed to handle a valid request.\n\nSome codes appear constantly. A 200 confirms everything is fine. A 301 says a resource has moved permanently. A 400 means the request was malformed, a 401 means authentication is required, and a 403 means access is forbidden. The famous 404 means the requested thing was not found. On the server side, a 500 is a generic internal error and a 503 means the service is temporarily unavailable.\n\nGratisAPI ships the full list as data. You can fetch it from /api/http-status/index.json and get an array of objects, each with a code, a short name, and a description. This is handy for building lookup tools, documentation, or teaching material without typing the whole table by hand.\n\nStatus codes matter because they let clients react intelligently. A program can retry on a 503, prompt for login on a 401, or show a friendly message on a 404, all by inspecting a single number. Treating the status code as the first thing you check makes debugging faster and your software more resilient to the many ways a request can go wrong.",
      "word_count": 305,
      "reading_time_min": 2,
      "try_api": "http-status",
      "url": "https://gratisapi.com/api/articles/reference-http-status-codes"
    },
    {
      "id": "world-languages-of-the-world",
      "title": "The Languages of the World",
      "category": "Culture",
      "author": "The GratisAPI Team",
      "date": "2023-03-12",
      "tags": [
        "languages",
        "culture"
      ],
      "summary": "Around 7,000 languages are spoken today, though a small handful account for most speakers. This article surveys the diversity and distribution of human language.",
      "body": "Human beings speak somewhere around 7,000 languages, an astonishing variety given that we are all one species. Yet this diversity is unevenly spread. A few dozen languages account for the vast majority of speakers, while thousands are spoken by only small communities and many are at risk of disappearing within a generation.\n\nThe most widely spoken languages by total speakers include English, Mandarin Chinese, Hindi, Spanish, and Arabic. Mandarin has the most native speakers, while English leads once second language learners are counted, thanks to its role in business, science, and the internet. These giants coexist with languages spoken by only a handful of elders in remote regions.\n\nLanguages are grouped into families that share a common ancestor. The Indo-European family stretches from Iceland to India and includes English, Russian, Persian, and Hindi. Other major families include Sino-Tibetan, Afro-Asiatic, Niger-Congo, and Austronesian. Some languages, called isolates, have no known relatives at all.\n\nLanguage is more than a tool for communication. It encodes a community's history, humour, and way of seeing the world, and when a language dies much of that knowledge vanishes with it. Linguists estimate that a language falls silent every few weeks, which has prompted major revitalisation efforts around the globe.\n\nWriting systems add another layer of variety. Some languages use alphabets, others use syllabaries, and still others use thousands of characters. The GratisAPI languages dataset at /api/languages/index.json provides names and codes for reference, which is useful for building localisation tools, quizzes, or multilingual applications that need a consistent list to work from.",
      "word_count": 255,
      "reading_time_min": 1,
      "try_api": "languages",
      "url": "https://gratisapi.com/api/articles/world-languages-of-the-world"
    },
    {
      "id": "science-noble-gases",
      "title": "The Noble Gases",
      "category": "Science",
      "author": "The GratisAPI Team",
      "date": "2023-03-12",
      "tags": [
        "chemistry",
        "elements",
        "noble-gases"
      ],
      "summary": "The noble gases are a family of remarkably unreactive elements whose stability comes from their perfectly filled electron shells.",
      "body": "Tucked into the far right column of the periodic table sits a quiet aristocracy of elements: the noble gases. This group includes helium, neon, argon, krypton, xenon, and the radioactive radon, with the synthetic oganesson rounding out the bottom. What unites them is a striking reluctance to react with anything at all.\n\nThe reason lies in their electron structure. Each noble gas has a complete outer shell of electrons, the most stable arrangement an atom can achieve. Because they have nothing to gain or lose by bonding, they float through the world as isolated single atoms rather than forming molecules or compounds. For decades chemists believed they were entirely inert, which earned them the older name inert gases.\n\nThat reputation cracked in 1962 when chemists coaxed xenon into forming compounds with fluorine, the most aggressive of all elements. Still, such reactions require extreme conditions and remain exotic curiosities.\n\nDespite their aloofness, the noble gases are deeply woven into daily life. Helium fills balloons and cools the superconducting magnets in MRI machines. Neon glows red orange in bright signage, while argon fills incandescent bulbs and shields welds from oxygen. Krypton and xenon appear in specialized lighting and camera flashes. Radon, by contrast, is a health hazard that seeps from certain soils into basements.\n\nHelium is also cosmically abundant, forged in the Big Bang and in the cores of stars, making it the second most common element in the universe after hydrogen. You can look up all six naturally occurring noble gases, along with their atomic numbers and properties, through the GratisAPI endpoint at /api/elements/index.json.",
      "word_count": 263,
      "reading_time_min": 1,
      "try_api": "elements",
      "url": "https://gratisapi.com/api/articles/science-noble-gases"
    },
    {
      "id": "howto-async-await",
      "title": "Using async and await with GratisAPI",
      "category": "Tutorials",
      "author": "The GratisAPI Team",
      "date": "2023-03-09",
      "tags": [
        "javascript",
        "async",
        "await"
      ],
      "summary": "Rewrite your GratisAPI calls with async/await for flatter, more readable code that handles errors cleanly.",
      "body": "Promise chains work, but async and await make asynchronous code read like ordinary sequential code. Because GratisAPI endpoints are simple JSON files, they are a perfect place to practice the pattern.\n\nDeclare a function with the async keyword, then use await to pause until each promise settles. Wrap the logic in a try/catch block so that both network failures and parsing problems land in one place:\n\nasync function getColors() {\n  try {\n    const response = await fetch(\"https://gratisapi.com/api/colors/index.json\");\n    if (!response.ok) throw new Error(\"HTTP \" + response.status);\n    const data = await response.json();\n    return data;\n  } catch (error) {\n    console.error(\"Failed to load colors:\", error);\n    return null;\n  }\n}\n\nNotice the response.ok check. The fetch() promise resolves even when the server returns a 404, so without this guard a missing endpoint would slip through and only fail later when you tried to use undefined data. Throwing early keeps your error handling honest.\n\nBecause await unwraps the promise for you, the returned data is a normal JavaScript object you can immediately loop over. If you need to load several endpoints at once, do not await them one after another in a loop, which runs them in series. Instead kick them all off and await Promise.all, so the requests overlap:\n\nconst [colors, quotes] = await Promise.all([getColors(), getQuotes()]);\n\nThis parallel approach matters more as you combine datasets. GratisAPI serves each collection as a complete file, so two endpoints mean two independent downloads that the browser can run concurrently. The result is code that is both easier to read and faster than a naive sequential chain.",
      "word_count": 258,
      "reading_time_min": 1,
      "try_api": "colors",
      "url": "https://gratisapi.com/api/articles/howto-async-await"
    },
    {
      "id": "freedom-gratis-vs-libre",
      "title": "Gratis vs Libre: Two Kinds of Free",
      "category": "Philosophy",
      "author": "The GratisAPI Team",
      "date": "2023-03-02",
      "tags": [
        "gratis",
        "libre",
        "comparison"
      ],
      "summary": "English uses one word, free, for two unrelated ideas, and separating them is essential to thinking clearly about software.",
      "body": "English is unusually clumsy here. The single word free must carry two ideas that have nothing necessary to do with each other: a price of zero and a grant of liberty. The free software movement popularized a memorable slogan to keep them apart, contrasting free as in free beer with free as in free speech.\n\nGratis names the first idea, cost. Libre names the second, freedom. Because they are independent properties, any combination is possible. A program can be gratis and libre, like most GNU tools. It can be libre but sold for a price. It can be gratis but proprietary, like many advertising-funded apps you download without paying. And of course it can be neither, sold under restrictive terms.\n\nThe trap most people fall into is assuming that no price means freedom. It does not. A gratis application can still forbid you from copying it, hide its source code, spy on you, and stop working the moment its maker decides. You paid nothing, but you control nothing. The absence of a bill is not the presence of liberty.\n\nThe reverse confusion also happens. People hear that free software can be sold and assume the movement is about business models. It is not. Whether money changes hands is beside the point; what matters is which freedoms travel with the software.\n\nThinking clearly requires holding both axes in mind at once. Ask two separate questions of any tool: what does it cost me, and what may I do with it? The answers are unrelated, and a full picture needs both.\n\nGratisAPI deliberately pursues both kinds of free. It costs nothing, and its code and data are openly licensed so your freedoms are real. The name is a small joke about a serious distinction that too many discussions still blur.",
      "word_count": 298,
      "reading_time_min": 1,
      "try_api": "birds",
      "url": "https://gratisapi.com/api/articles/freedom-gratis-vs-libre"
    },
    {
      "id": "reference-what-is-json",
      "title": "What is JSON?",
      "category": "Reference",
      "author": "The GratisAPI Team",
      "date": "2023-03-01",
      "tags": [
        "json",
        "data",
        "format"
      ],
      "summary": "JSON is a lightweight, human readable format for exchanging structured data between programs.",
      "body": "JSON stands for JavaScript Object Notation. It is a text format for representing structured data, and it has become the common language of web APIs. Despite the name, JSON is not tied to JavaScript; almost every programming language can read and write it.\n\nJSON is built from a few simple pieces. There are objects, which are collections of name and value pairs wrapped in curly braces. There are arrays, which are ordered lists wrapped in square brackets. And there are basic values: strings of text, numbers, the words true and false, and the empty value null. By nesting these pieces you can describe almost any data, from a single number to a deep tree of records.\n\nThe format became popular because it is both easy for people to read and easy for machines to parse. Compared to older formats, JSON is compact and has very little ceremony. A person can glance at a JSON document and understand its shape, while a program can turn that same text into native data structures in a single call.\n\nEvery dataset in GratisAPI is delivered as JSON. When you request an address such as /api/ascii/index.json, the server returns a JSON document, usually an array of objects where each object describes one entry. Your code parses that text and works with the values directly.\n\nA few rules keep JSON reliable. Strings must use double quotes, names in objects must be strings, and there are no trailing commas or comments. These constraints make the format strict enough that parsers rarely disagree about what a document means. That predictability is exactly why JSON has become the default choice for sending data across the web, and why every reference dataset in this project speaks it.",
      "word_count": 287,
      "reading_time_min": 1,
      "try_api": "ascii",
      "url": "https://gratisapi.com/api/articles/reference-what-is-json"
    },
    {
      "id": "howto-fetch-javascript",
      "title": "Fetching Data with the JavaScript fetch() API",
      "category": "Tutorials",
      "author": "The GratisAPI Team",
      "date": "2023-02-14",
      "tags": [
        "javascript",
        "fetch",
        "browser"
      ],
      "summary": "Learn how to pull GratisAPI data straight into the browser using the built-in fetch() function, with no libraries required.",
      "body": "Every GratisAPI endpoint is a plain JSON file served over HTTPS, which makes the browser's built-in fetch() function all you need. There are no API keys to manage, no headers to set, and no rate limits to worry about. You simply request a URL and read the response.\n\nHere is the core pattern. Call fetch() with the full endpoint URL, then convert the response to JSON with the .json() method, which itself returns a promise:\n\nfetch(\"https://gratisapi.com/api/quotes/index.json\")\n  .then(response => response.json())\n  .then(data => console.log(data))\n  .catch(error => console.error(error));\n\nThe /api/quotes/index.json endpoint returns an object describing the collection along with the list of items. Because the data is static, the same request always returns the same shape, so you can rely on the structure when you write your rendering code.\n\nA few practical tips. First, always attach a .catch() handler so that network failures do not silently break your page. Second, remember that fetch() only rejects on network errors, not on HTTP error statuses, so if you need to detect a missing file you should check response.ok before parsing. Third, because the files never change without a new deploy, the browser and any intermediate CDN cache them aggressively, which keeps repeat visits fast.\n\nOnce you have the parsed data, rendering it is ordinary DOM work. Loop over the array of records, build elements, and append them to the page. Since GratisAPI ships whole datasets in a single file, you get everything in one round trip and can filter or sort on the client without additional requests. This makes fetch() an ideal match for the API's static, no-nonsense design.",
      "word_count": 264,
      "reading_time_min": 1,
      "try_api": "quotes",
      "url": "https://gratisapi.com/api/articles/howto-fetch-javascript"
    },
    {
      "id": "world-currencies-explained",
      "title": "World Currencies Explained",
      "category": "Culture",
      "author": "The GratisAPI Team",
      "date": "2023-02-08",
      "tags": [
        "currencies",
        "economics"
      ],
      "summary": "There are around 180 currencies in circulation worldwide, each identified by a three-letter code. This article introduces how currencies are named, coded, and used.",
      "body": "Every day trillions of units of value change hands in currencies whose names most of us never encounter. There are roughly 180 currencies recognised as legal tender around the world, though the exact count shifts as nations adopt shared money or introduce new units.\n\nThe backbone of the modern system is the ISO 4217 standard, which assigns each currency a three-letter code. The first two letters usually match the country code and the third names the currency itself, so the United States dollar becomes USD, the British pound becomes GBP, and the Japanese yen becomes JPY. These codes make international banking and travel far less error prone than spelled out names would be.\n\nSome currencies are shared across many countries. The euro, introduced in 1999, is used by twenty European Union members and several other territories. The CFA franc circulates across much of West and Central Africa. Sharing a currency removes exchange costs between partners but also removes each country's ability to set its own monetary policy.\n\nCurrencies also carry deep cultural weight. Symbols such as the dollar sign, the pound sign, and the yen sign are instantly recognisable, and the imagery on banknotes often celebrates national heroes, landmarks, and wildlife. A country's money is one of the most widely circulated pieces of design it ever produces.\n\nThe GratisAPI currencies dataset at /api/currencies/index.json lists codes, names, and symbols in a clean format suitable for building converters, e-commerce checkouts, or educational tools. Because exchange rates move constantly, the dataset focuses on stable reference information rather than live prices, giving you a reliable foundation to combine with a rates feed of your choosing.",
      "word_count": 271,
      "reading_time_min": 1,
      "try_api": "currencies",
      "url": "https://gratisapi.com/api/articles/world-currencies-explained"
    },
    {
      "id": "science-how-to-read-atomic-mass",
      "title": "How to Read Atomic Mass",
      "category": "Science",
      "author": "The GratisAPI Team",
      "date": "2023-02-08",
      "tags": [
        "chemistry",
        "atoms",
        "atomic-mass"
      ],
      "summary": "Atomic mass is the weighted average of an element's isotopes, and understanding it unlocks how chemists count atoms by weighing them.",
      "body": "Every entry on the periodic table lists a number that usually falls just below the element symbol: its atomic mass. Reading this number correctly reveals a surprising amount about how atoms are built and why chemistry works the way it does.\n\nAtomic mass is measured in unified atomic mass units, abbreviated u or sometimes called daltons. One unit is defined as one twelfth of the mass of a carbon-12 atom. A single proton and a single neutron each weigh almost exactly one unit, while electrons are so light that they barely register.\n\nHere is the subtlety. The atomic mass printed on the table is rarely a whole number. Chlorine, for example, is listed as roughly 35.45. This is because most elements exist as a mixture of isotopes, atoms of the same element that carry different numbers of neutrons. Chlorine occurs as about three quarters chlorine-35 and one quarter chlorine-37, and the listed value is the weighted average of those two.\n\nThis average matters enormously in the laboratory. Because atoms are far too small to count directly, chemists weigh them instead. The atomic mass in grams defines one mole, a fixed count of roughly 602 followed by twenty one zeros of particles. Weigh out that many grams and you know exactly how many atoms you have.\n\nTo distinguish concepts, note that mass number counts protons plus neutrons in a single atom and is always a whole number, while atomic mass is the measured average across isotopes. You can pull atomic mass values for every element from the GratisAPI endpoint at /api/elements/index.json and use them to calculate the molar mass of any compound you like.",
      "word_count": 273,
      "reading_time_min": 1,
      "try_api": "elements",
      "url": "https://gratisapi.com/api/articles/science-how-to-read-atomic-mass"
    },
    {
      "id": "reference-what-is-rest",
      "title": "What is REST?",
      "category": "Reference",
      "author": "The GratisAPI Team",
      "date": "2023-02-08",
      "tags": [
        "rest",
        "api",
        "http"
      ],
      "summary": "REST is an architectural style for web APIs built around resources and standard HTTP methods.",
      "body": "REST stands for Representational State Transfer. It is not a protocol or a library but a set of design principles for building web services. Roy Fielding described it in his doctoral work in 2000, and it has since become the dominant way people design web APIs.\n\nThe central idea of REST is the resource. A resource is any thing your system knows about, such as a user, an order, or a country. Each resource has a stable address, and you interact with it using the standard methods of the web. You retrieve a resource, create a new one, update it, or remove it, all through the same small vocabulary of HTTP verbs.\n\nREST APIs are described as stateless, meaning each request carries everything the server needs to understand it. The server does not remember previous requests from the same client. This makes REST services easy to scale, because any server can handle any request without shared memory of past conversations.\n\nResponses in REST APIs are usually representations of a resource in a convenient format, most often JSON. When you fetch a country from a REST service, you get a JSON document describing that country. GratisAPI follows a REST inspired layout. Each dataset sits at its own address, such as /api/tcp-ports/index.json, and returns a representation you can read directly.\n\nA well designed REST API is predictable. If you know how to fetch one kind of resource, you can guess how to fetch another. This consistency is what makes REST pleasant to work with. While strict REST has formal rules about links and discoverability, most everyday APIs adopt the practical core: clear addresses, standard methods, and structured responses. That practical core is enough to make different systems cooperate reliably across the web.",
      "word_count": 290,
      "reading_time_min": 1,
      "try_api": "tcp-ports",
      "url": "https://gratisapi.com/api/articles/reference-what-is-rest"
    },
    {
      "id": "freedom-what-libre-means",
      "title": "What \"Libre\" Really Means",
      "category": "Philosophy",
      "author": "The GratisAPI Team",
      "date": "2023-02-08",
      "tags": [
        "libre",
        "liberty",
        "terminology"
      ],
      "summary": "Libre refers to freedom rather than price, describing software that respects the liberty of the people who use it.",
      "body": "Libre is a word English has borrowed from French and Spanish to name a specific idea: freedom, not price. When people say software is free as in freedom, libre is what they mean. It describes the liberties a user holds over a program, entirely apart from whether any money changed hands.\n\nLibre software can be sold. Nothing about the concept requires a price of zero. A vendor may charge for copies, support, or convenience. What makes the software libre is that everyone who receives a copy also receives the freedom to run it, study it, modify it, and pass it along. Liberty travels with the code.\n\nThe distinction turns on control. With proprietary software, the developer holds power over the user, deciding what the program may and may not do and forbidding inspection of its inner workings. Libre software inverts that relationship. The user, alone or in community, holds the power to understand and change the tool they depend on.\n\nThis is not a small technical footnote. Software increasingly mediates work, communication, health, and civic life. A program you cannot study or alter is a program that governs you on terms set by someone else. Libre software insists that the people affected by a tool should be able to control it.\n\nThe Free Software Foundation formalized this idea as four essential freedoms, which together define whether a program is libre. A tool that grants all four respects its users; one that withholds any of them does not, regardless of its price.\n\nGratisAPI aims to be libre as well as gratis. The data and the code are openly licensed so that anyone may inspect, adapt, and rebuild them. Cost is only part of freedom, and libre names the part that lasts.",
      "word_count": 290,
      "reading_time_min": 1,
      "try_api": "planets",
      "url": "https://gratisapi.com/api/articles/freedom-what-libre-means"
    },
    {
      "id": "world-how-many-countries",
      "title": "How Many Countries Are There?",
      "category": "Culture",
      "author": "The GratisAPI Team",
      "date": "2023-01-15",
      "tags": [
        "countries",
        "geography"
      ],
      "summary": "The number of countries in the world depends on who is counting, but the most widely used figure is 195. This article explains where that number comes from.",
      "body": "Ask how many countries there are and you will get several different answers, all of them defensible. The most commonly cited figure is 195, which counts the 193 member states of the United Nations plus two observer states, the Holy See and the State of Palestine. This is the number most textbooks and reference works use today.\n\nThe count grows if you include territories with partial recognition. Places such as Taiwan, Kosovo, and Western Sahara are recognised by some governments but not others, so whether they appear on a list depends on the political stance of whoever is compiling it. There is no single global authority that settles these disputes definitively.\n\nThe idea of a country is also more slippery than it first appears. Sovereignty, permanent population, defined territory, and the capacity to enter relations with other states are the classic criteria set out in the Montevideo Convention of 1933. Yet many entities meet some but not all of these tests, which is why the edges of the list stay blurry.\n\nThe number has changed enormously over the past century. The breakup of empires after the two world wars, the wave of African independence in the 1960s, and the collapse of the Soviet Union and Yugoslavia in the early 1990s each added dozens of new states. South Sudan, which became independent in 2011, is the newest widely recognised country.\n\nIf you want to explore the data yourself, the GratisAPI countries dataset is available at /api/countries/index.json, with details on capitals, regions, and populations. It is a good starting point for anyone building quizzes, dashboards, or teaching tools that need a clean, consistent list of the world's nations.",
      "word_count": 276,
      "reading_time_min": 1,
      "try_api": "countries",
      "url": "https://gratisapi.com/api/articles/world-how-many-countries"
    },
    {
      "id": "science-periodic-table-explained",
      "title": "The Periodic Table Explained",
      "category": "Science",
      "author": "The GratisAPI Team",
      "date": "2023-01-15",
      "tags": [
        "chemistry",
        "elements",
        "periodic-table"
      ],
      "summary": "The periodic table organizes every known chemical element by its properties, revealing patterns that have guided chemistry for over 150 years.",
      "body": "The periodic table is one of the most powerful organizing tools in all of science. It arranges the chemical elements in order of increasing atomic number, which is the number of protons in an atom's nucleus. The genius of the table lies not in the ordering alone but in the way it wraps into rows and columns so that elements with similar chemical behavior line up in the same vertical group.\n\nDmitri Mendeleev published an early version in 1869. His arrangement was so insightful that he left gaps for elements not yet discovered and correctly predicted their properties. Modern tables contain 118 confirmed elements, from hydrogen at number one to oganesson at number 118.\n\nEach horizontal row is called a period, and each vertical column is called a group. Elements in the same group share the same number of electrons in their outermost shell, which largely determines how they react. The alkali metals in group one are soft and violently reactive with water, while the noble gases in group eighteen are almost completely unreactive.\n\nThe table also separates into broad regions. Metals occupy the left and center, nonmetals sit on the upper right, and a diagonal band of metalloids straddles the boundary. Below the main body lie the lanthanides and actinides, two rows of elements pulled out to keep the table compact.\n\nYou can explore structured data for every element, including symbol, atomic number, and atomic mass, through the GratisAPI endpoint at /api/elements/index.json. Having the elements in machine readable form makes it easy to build quizzes, reference tools, or visualizations that bring the periodic system to life.",
      "word_count": 267,
      "reading_time_min": 1,
      "try_api": "elements",
      "url": "https://gratisapi.com/api/articles/science-periodic-table-explained"
    },
    {
      "id": "reference-what-is-an-api",
      "title": "What is an API?",
      "category": "Reference",
      "author": "The GratisAPI Team",
      "date": "2023-01-15",
      "tags": [
        "api",
        "basics",
        "web"
      ],
      "summary": "An introduction to application programming interfaces and why they matter for modern software.",
      "body": "An API, or application programming interface, is a set of rules that lets one piece of software talk to another. Instead of a human clicking buttons in an app, a program sends a request and receives a structured response it can process automatically. APIs define what requests are allowed, what data must be provided, and what will come back.\n\nThink of an API as a contract between a provider and a consumer. The provider promises that if you ask a question in the agreed format, you will get an answer in a predictable shape. This lets teams build on top of each other's work without needing to understand every internal detail. A weather app does not calculate the forecast itself; it asks a weather API and displays the result.\n\nAPIs come in many styles. Web APIs, which are the most common today, work over the same protocols that power websites. You send a request to a web address and receive data back, often in JSON. Other kinds of interfaces exist inside operating systems and libraries, but when people say API today they usually mean a web service.\n\nGratisAPI is itself a collection of small, free web APIs. Each dataset lives at a stable web address that returns plain JSON. For example, you can fetch a list of HTTP methods from /api/http-methods/index.json or color definitions from /api/colors/index.json. Because the data is static, there are no keys, no rate limits, and no sign up required.\n\nUnderstanding APIs is the foundation for almost everything else in modern development. Once you grasp the idea of a request and a structured response, concepts like REST, JSON, and status codes fall into place naturally. The rest of this reference series builds on that single idea.",
      "word_count": 289,
      "reading_time_min": 1,
      "try_api": "http-methods",
      "url": "https://gratisapi.com/api/articles/reference-what-is-an-api"
    },
    {
      "id": "freedom-what-gratis-means",
      "title": "What \"Gratis\" Really Means",
      "category": "Philosophy",
      "author": "The GratisAPI Team",
      "date": "2023-01-14",
      "tags": [
        "gratis",
        "terminology",
        "cost"
      ],
      "summary": "The word gratis describes something you can obtain without paying money, and understanding it helps clear up a common confusion in software.",
      "body": "The word gratis comes from Latin and describes something offered at no monetary cost. When people say software is free as in free beer, gratis is the sense they mean. You do not hand over money to obtain it, download it, or use it. That is the whole of the claim.\n\nGratis says nothing about what you are allowed to do with the thing once you have it. A gratis program might forbid you from copying it, studying how it works, or sharing it with a friend. Many popular applications cost nothing to install yet come wrapped in restrictive terms. They are gratis but not liberating.\n\nThe English word free carries both meanings at once, which is the root of endless misunderstanding. A price of zero and a grant of liberty are entirely different properties, and a program can have one, both, or neither. Several other languages avoid this trap by using separate words, which is why English speakers often borrow gratis and libre to be precise.\n\nGratis matters because cost is a real barrier. A student, a researcher in a poor region, or a hobbyist tinkering on a weekend may simply not be able to pay. Removing the price tag widens the circle of people who can participate. But a gratis offer can also be a trap when the true cost is hidden in advertising, data collection, or lock-in.\n\nGratisAPI is gratis in the plainest sense. There is no fee, no paid tier, and no invoice. Yet we consider that only half of what a free service should be. Understanding gratis on its own, separate from questions of liberty, is the first step toward thinking clearly about software freedom.",
      "word_count": 280,
      "reading_time_min": 1,
      "try_api": "birds",
      "url": "https://gratisapi.com/api/articles/freedom-what-gratis-means"
    }
  ]
}
