World-class OpenAPI specs without the schema grind

World-class OpenAPI specs without the schema grind

A standard library of all the foundational schemas you'll ever need—from email addresses to currency codes—so you never have to bother with JSON Schema again

Commercial library with perpetual pricing. Pay once, own forever

Maintained by a member of the JSON Schema Technical Steering Committee

Before

openapi.yaml
openapi: 3.1.0
paths:
  /users:
    post:
      requestBody:
        content:
          application/json:
            schema:
              type: object
              properties:
                email:
                  type: string
                  pattern: '^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
                  description: Email address
                country:
                  type: string
                  pattern: '^[A-Z]{2}$'
                  description: ISO 3166-1 alpha-2 country code
                currency:
                  type: string
                  enum: [ AED, AFN, ALL, AMD, ANG, AOA, ARS, AUD, AWG, AZN, BAM, BBD, BDT,
                          BGN, BHD, BIF, BMD, BND, BOB, BRL, BSD, BTN, BWP, BYN, BZD, CAD,
                          CDF, CHF, CLP, CNY, COP, CRC, CUP, CVE, CZK, DJF, DKK, DOP, DZD,
                          EGP, ERN, ETB, EUR, FJD, FKP, FOK, GBP, GEL, GGP, GHS, GIP, GMD,
                          GNF, GTQ, GYD, HKD, HNL, HRK, HTG, HUF, IDR, ILS, IMP, INR, IQD,
                          IRR, ISK, JEP, JMD, JOD, JPY, KES, KGS, KHR, KID, KMF, KRW, KWD,
                          KYD, KZT, LAK, LBP, LKR, LRD, LSL ]
                  description: ISO 4217 currency code
                website:
                  type: string
                  pattern: '^https'
                  description: Website URL
                created_at:
                  type: string
                  pattern: '^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z?$'
                  description: ISO 8601 datetime
                language:
                  type: string
                  pattern: '^[a-z]{2}(-[A-Z]{2})?$'
                  description: Language code
Problems (4)
100+ lines of repetitive validation code
Broken regex patterns copied from ChatGPT
Incomplete or incorrect enumerations
No standards compliance guarantees

After

openapi.yaml
openapi: 3.1.0
paths:
  /users:
    post:
      requestBody:
        content:
          application/json:
            schema:
              type: object
              properties:
                email:
                  $ref: './std/ietf/email/address.json'
                country:
                  $ref: './std/iso/country/2020/alpha-2.json'
                currency:
                  $ref: './std/iso/currency/2015/alpha-code.json'
                website:
                  $ref: './std/ietf/uri/url.json'
                created_at:
                  $ref: './std/iso/datetime/2019/datetime/calendar-extended.json'
                language:
                  $ref: './std/ietf/language/tag.json'
Output (4)
Clean and readable OpenAPI definitions
Standards-backed validation (IETF RFC's, ISO, etc)
Guaranteed schema correctness
Took 5 minutes to write

Built on the foundations of our digital world

Every schema in this library represents careful implementation of the standards that power the modern internet (many behind expensive paywalls), ensuring your APIs are built on proven, battle-tested, and compliant foundations.

Most API companies waste months reinventing the wheel, and still doing it wrong

Your company is smarter than that

Correctness

You are writing schemas that are likely broken

Thousands of developers waste time reinventing the same complex foundational schemas, each with their own bugs and edge cases.


And you are probably not even unit testing your schemas for correctness

Strictness

Your schemas are either too strict or uselessly loose

Designing robust and correct schemas takes a ton of time, deep expertise, and access to standards. But you need to ship your APIs yesterday.


And you might even be introducing security vulnerabilities with overly loose schemas

Productivity

Writing schemas from scratch takes 100x longer

Designing schemas is time consuming. Snap in battle-tested schemas like building blocks and ship your OpenAPI specs in hours, not weeks.


Why waste your time designing complex schemas that have already been designed?

Use the schemas your way

We don't lock you in. Choose the method that works best for your workflow

HTTPS URLs

HTTPS URLs

Directly reference schemas from schemas.sourcemeta.com using the $ref JSON Schema keyword and de-reference them with well known OpenAPI tools like redocly bundle

OpenAPI Editors

OpenAPI Editors

Most popular OpenAPI editors, such as Scalar, can de-reference external HTTPS requests to schemas hosted in public schema registries like schemas.sourcemeta.com

Git Submodule

Git Submodule

Our schemas are publicly available on GitHub. Pull them as a submodule like any other dependency and reference them from your OpenAPI specs using relative file paths

Schema Registries

Schema Registries

For extra power and organisation-wide API Governance programs, ingest the schemas in JSON Schema 2020-12 compatible registries like the Sourcemeta Registry

Download Archive

Download Archive

Often useful in scripting environments. Fetch the latest ZIP or tarball from GitHub Releases and use the JSON files that come with it as you wish

Copy & Paste

Copy & Paste

Sometimes you don't need to get fancy. You can always browse the schemas in schemas.sourcemeta.com and just copy-paste the ones you need

Pricing

All schemas are publicly available on GitHub for evaluation, auditing, and contributions. However, any use of these schemas related to a for-profit product or service requires a commercial license. Read the license document for more details.

Do you have questions regarding the license? Don't hesitate to reach out!

Community

€0

Free forever for non-commercial projects such as personal projects, open specifications, research, and open-source organisations.

Note: Requires attribution

View on GitHub

OEM

Custom

Offer our schemas to your end users as part of your own product (i.e. OpenAPI editors and API management platforms) in a white-labelling manner and without attribution

Let's Talk!
Most Popular

Commercial

€2,110

One-time payment

  • Commercial use (for a single company)
  • Lifetime access
  • Free updates forever
  • All future schemas included
  • Premium support (Slack Connect or Discord)
  • Publish public OpenAPI specs that use our schemas
  • Request any new schemas you need
Purchase License

Contact us for a full refund within 30-days of purchase. No questions asked

This library is maintained by a member of the JSON Schema Technical Steering Committee. Your purchase directly supports our open-source contributions and continuous involvement in the JSON Schema ecosystem. Thanks for your help making the JSON Schema standard thrive!

An investment that quickly pays for itself

Solve the OpenAPI authoring problem for your company forever

A week of developer salary

A fraction of the time and cost to produce these schemas yourself

Perpetual ownership

Every project, every team, forever. Including all new schemas

World-class support included

Have an API and JSON Schema expert on your speed dial for help

6+

Months of work saved per API

Avoid a whole class of input/output correctness and security bugs

Do you have any questions?

I'm Juan Cruz Viotti, founder of Sourcemeta, member of the JSON Schema Technical Steering Committee, O'Reilly author, and award-winning University of Oxford alumnus.

I'd love to discuss how JSON Schema, OpenAPI, and Sourcemeta tooling can help you build world class APIs.

Trusted by elite API architects

See what the world's leading specification experts are saying

"This is definitely going to become an incredibly important reference library for defining concepts using best in class standards"

"This is a terrific project and should be a standard subscription for any enterprise working with JSON Schema"

"This aligns exactly with my thinking! OpenAPI should not include schemas but should reference them externally from a source of truth like this one"

"Before this library, defining foundational schemas in an enterprise was a time-consuming, error-prone task that could result in inconsistencies. This library is a game-changer, delivering huge time savings while ensuring improved API consistency and strong governance of API definition files"

"Right now there is a big disconnect between ontology work and API work. This project has the potential to bridge that gap by making widely used ontologies available on JSON Schema"

Frequently Asked Questions

Do you have any other questions regarding the schemas? Don't hesitate to reach out!

Yes. However, if your API is for-profit, you'll need a commercial license. Your end users can freely consume your published OpenAPI specification without needing their own license, as they're using your specification rather than directly consuming our schemas.

Absolutely. These schemas are designed as composable building blocks. Reference them, extend them, or add additional constraints as you wish.

All schemas target JSON Schema 2020-12, which is the dialect used by OpenAPI v3.1 and later. Support for earlier JSON Schema dialects will be added in future releases.

We regularly update schemas to reflect new standards, fix bugs, and expand coverage for additional specifications. We follow semantic versioning, so you can upgrade at your own pace without breaking existing specifications.

Yes. We welcome contributions via pull requests on GitHub.

Yes, as long as you preserve the license-related metadata keywords that identify the schema origin and licensing terms for downstream consumers.

Yes. This qualifies under the Community license. Users of your specification can freely use the schemas as they are consuming your specification rather than our schemas directly.

Yes. A commercial license is required for any for-profit venture, regardless of whether your code is open-source.

If you use the schemas unmodified, the embedded metadata provides automatic attribution. No additional action is required.

Ready to solve OpenAPI design
at your company forever?

One payment. Perpetual access. Never write schemas from scratch again.

30-day money-back guarantee • Maintained by a JSON Schema TSC member

Open Source

We maintain key open-source projects that make working with JSON Schema a breeze. Explore our projects on GitHub to learn more!