APIGit vs ReadMe
ReadMe is a developer hub: guides written in a visual editor, an API reference with authenticated Try It, a changelog and usage metrics, with optional two-way sync to your Git repository. APIGit starts from the repository, hosts it, and adds API design, governance and mock servers that ReadMe does not have.
ReadMe is a hosted developer hub for API documentation by ReadMe. Facts checked against its public documentation on 19 November 2026.
APIGit
ReadMe
The short version
Git as the source, not a mirror
ReadMe stores content in its own Git-backed store and can sync it both ways with your repository. In APIGit the repository is where the content lives, and it has an address you clone.
Design, rules and mocks before the docs
ReadMe documents an API. APIGit also edits the OpenAPI file in a form or as code, checks it against Spectral rules, finds breaking changes and serves a mock.
ReadMe's hub goes further
API keys shown to signed-in readers, per-user request history, usage metrics, a changelog and forums are ReadMe's ground.
Git, side by side
An APIGit project is a Git repository from its first commit. This is what that means next to ReadMe, topic by topic.
| Topic | APIGit | ReadMe |
|---|---|---|
| Where your API files live | Yes:In a Git repository that APIGit hosts: specs, Markdown and mock scripts as files | Partly:ReadMe's own Git-backed store, with optional sync to your repository |
| Clone and push with any Git client | Yes:HTTPS with a token, or SSH at git.apigit.com | No:You clone your own synced repository; ReadMe documents no Git address of its own |
| Branches and tags | Yes:Git branches and tags, created in the browser or pushed from your machine | Partly:ReadMe branches tied to versions, on Pro and above |
| Pull requests and review | Yes:Built in: reviewers, approvals, and merge, rebase or squash | Partly:A review tab with a line-by-line diff and a preview; pull requests happen on your Git host |
| Commit history and diff | Yes:Every commit of every branch, with a unified or split diff | Partly:Page history with diff and restore |
| Working with GitHub, GitLab and others | Yes:Optional: two-way sync with a remote repository, or push mirrors (Enterprise) | Yes:Two-way sync with GitHub, GitLab and Bitbucket Cloud, on every plan |
- Yes:Has it
- Partly:Has part of it; the cell says which
- No:Does not have it
Feature by feature
Design, documentation, mock servers, governance, testing, agents and plans. Where ReadMe has something APIGit lacks, the table says so.
| Topic | APIGit | ReadMe |
|---|---|---|
| API design | ||
| OpenAPI versions | Yes:OpenAPI 3.0 and 3.1, Swagger 2.0 | Yes:OpenAPI 3.0 and 3.1, Swagger 2.0 |
| Visual editor for OpenAPI | Yes:A form view beside the code view, with a diff before you commit | Yes:The API Designer, a form-based editor |
| AsyncAPI and GraphQL | Yes:Both: edit as code, preview and publish, in the same repository | Partly:Limited GraphQL; AsyncAPI is not listed |
| Documentation | ||
| Hosted documentation | Yes:One site for OpenAPI, AsyncAPI, GraphQL and Markdown, published from a commit | Yes:A hosted developer hub: guides, reference, changelog and forums |
| Custom domain | Yes:On Team and Enterprise | Yes:On every plan, the free one included |
| Try it console | Yes:Try It Out for OpenAPI, on every plan | Yes:Try It, with the reader's own API keys and request history |
| Private documentation | Yes:Members only, named external viewers, or a password-protected link | Yes:Private docs on Pro; SSO and roles on Enterprise |
| Mock servers | ||
| Hosted mock server from a spec | Yes:From OpenAPI documents or a GraphQL schema, with request validation | No:No mock server is documented |
| Mocks with your own code and state | Yes:Express.js scripts from the repository (Team and Enterprise) | No:No mock server is documented |
| Mock on your machine | Yes:apigit mock serve, from the working copy | No:No mock server is documented |
| Governance | ||
| Style rules for API descriptions | Yes:Spectral: two built-in rule sets, your own on Enterprise | Partly:An AI linter for the prose of guides; OpenAPI validation in its CLI |
| Breaking-change check | Yes:apigit breaking, between two Git refs, in a terminal or in CI | No:Not documented |
| API client and testing | ||
| API client for sending requests | Partly:Try It Out in the reference; no standalone client or saved collections | Partly:Try It in the reference, with authenticated requests |
| Test scenarios, runners and monitors | No:Not provided | No:Not provided |
| CLI and AI agents | ||
| Command line | Yes:apigit: lint, score, diff, breaking, preview, mock and publish; the checks run offline with no account | Yes:rdme uploads OpenAPI and Markdown, also as a GitHub Action |
| MCP server | Yes:One for each published document, and one for your account | Yes:An MCP server for the docs, on every plan |
| Plans | ||
| Free plan | Yes:1 user, 1 published document, 1 mock server | Yes:1 admin, 1 project, 1 published version, with a custom domain |
| First paid plan | Yes:Team: $24 a month, 3 seats included; $8 per further seat | Yes:Pro: $250 a month billed yearly, 5 admins |
Checked on 19 November 2026 against each vendor's public documentation and pricing pages. APIGit's column follows our documentation and pricing. Products change: if a cell is out of date, tell us and we will correct it. Product names are trademarks of their owners.
Where ReadMe is the better choice
A comparison that only lists our strengths is an advertisement. These are the things it does that we do not, or does better.
Writing for people who do not write YAML
ReadMe's visual editor and form-based API Designer let support, product and marketing staff write and fix pages without meeting Git. APIGit has a visual Markdown editor too, but every change there is a commit to a repository.
A hub that knows the reader
Signed-in readers see their own API keys in Try It, with their request history, and you see which endpoints and pages are used. APIGit publishes the docs and does not track API usage.
A custom domain on the free plan
ReadMe's free plan includes a custom domain and Git sync. In APIGit a custom domain needs the Team plan.
Choose ReadMe when
- Non-technical writers own the documentation
- Readers should see their own API keys and request logs in the docs
- You want usage metrics, a changelog and a forum in the hub
Choose APIGit when
- The team designs the API as well as documenting it
- Docs should be published from a reviewed commit
- You need mock servers and governance rules beside the docs
- You document AsyncAPI events as well as REST
Moving an API from ReadMe
Get the files out
With ReadMe's Git sync your pages are already Markdown files in a repository, with the OpenAPI definitions beside them. Otherwise export the OpenAPI file and the pages.
Bring the repository in
Migrate that repository into APIGit or commit the files to a new one. ReadMe's MDX components need replacing with plain Markdown or APIGit's components.
Set the navigation and publish
Arrange the pages in apigit.json, pick a theme, and publish a version from the commit on your own domain.
$ git clone git@git.apigit.com:acme/orders-api.git$ cd orders-api$ cp ~/Downloads/openapi.yaml .$ apigit lint openapi.yaml$ git add openapi.yaml$ git commit -m "Import the orders API"$ git pushQuestions about APIGit and ReadMe
What is the main difference between APIGit and ReadMe?
ReadMe has Git sync. How is APIGit different?
Does ReadMe have a mock server?
Does APIGit show API keys or usage metrics in the docs like ReadMe?
How does pricing compare?
Other comparisons
- APIGit vs Mintlify
A documentation platform for product and API docs
- APIGit vs Postman
An API client and testing platform
- APIGit vs SwaggerHub
An API design platform, now named Swagger Studio
- APIGit vs Stoplight
An API design and documentation platform
- APIGit vs Apidog
An all-in-one API design, debugging, testing, mock and documentation platform
- APIGit vs Redocly
An API documentation platform, with the open-source Redoc and Redocly CLI
- APIGit vs Insomnia
An open-source API client with a spec editor
- APIGit vs Bruno
An open-source, offline API client
- All products in one table
The comparison overview
Try it yourself
Worked examples from the learn hub, each with the output of the tools.
- Run a mock server from an OpenAPI file on your machine
One command starts a mock that answers every operation of an OpenAPI file with generated examples and refuses requests that do not match the description. What it returns, how it validates, and when to move it to a hosted mock.
- Bundle a multi-file OpenAPI description into one file
Splitting an OpenAPI description over files keeps it maintainable; many tools still want one file. apigit bundle resolves the external $refs into components and leaves internal ones as references. A four-file example, the output, and why to lint the bundle.
- oneOf vs anyOf in OpenAPI: the one payload that tells them apart
oneOf needs exactly one schema to match, anyOf at least one. The difference only shows on a payload that fits two schemas: oneOf refuses it, anyOf accepts it. The same request sent to both, with a mock server's answers.
- "invalid-ref ... does not exist" and "Can't resolve $ref": finding a broken reference
An OpenAPI $ref that points to nothing. How a linter and a bundler report it, how to read the path in the message, and the five usual causes: a typo, the wrong section, a moved file, a missing escape, a case difference.
Put one API in a repository and see
Create a free workspace, commit the OpenAPI file you already have, and open a pull request against it. It is Git from the first commit.
Free for individuals. No credit card.
$ npm install -g @apigit/cli$ apigit auth login$ apigit doc publish