Skip to content
All comparisons

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

Your editor, the browser or a coding agent
git push, git pull
A Git repository on APIGit
from a commit
Docs, mock servers and rule checks

ReadMe

The ReadMe editor
save
ReadMe's own content store
two-way sync
Your repository on GitHub, GitLab or Bitbucket
ReadMe keeps content in its own store and can sync it both ways with a repository you host elsewhere.

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.

TopicAPIGitReadMe
Where your API files liveYes:In a Git repository that APIGit hosts: specs, Markdown and mock scripts as filesPartly:ReadMe's own Git-backed store, with optional sync to your repository
Clone and push with any Git clientYes:HTTPS with a token, or SSH at git.apigit.comNo:You clone your own synced repository; ReadMe documents no Git address of its own
Branches and tagsYes:Git branches and tags, created in the browser or pushed from your machinePartly:ReadMe branches tied to versions, on Pro and above
Pull requests and reviewYes:Built in: reviewers, approvals, and merge, rebase or squashPartly:A review tab with a line-by-line diff and a preview; pull requests happen on your Git host
Commit history and diffYes:Every commit of every branch, with a unified or split diffPartly:Page history with diff and restore
Working with GitHub, GitLab and othersYes: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.

TopicAPIGitReadMe
API design
OpenAPI versionsYes:OpenAPI 3.0 and 3.1, Swagger 2.0Yes:OpenAPI 3.0 and 3.1, Swagger 2.0
Visual editor for OpenAPIYes:A form view beside the code view, with a diff before you commitYes:The API Designer, a form-based editor
AsyncAPI and GraphQLYes:Both: edit as code, preview and publish, in the same repositoryPartly:Limited GraphQL; AsyncAPI is not listed
Documentation
Hosted documentationYes:One site for OpenAPI, AsyncAPI, GraphQL and Markdown, published from a commitYes:A hosted developer hub: guides, reference, changelog and forums
Custom domainYes:On Team and EnterpriseYes:On every plan, the free one included
Try it consoleYes:Try It Out for OpenAPI, on every planYes:Try It, with the reader's own API keys and request history
Private documentationYes:Members only, named external viewers, or a password-protected linkYes:Private docs on Pro; SSO and roles on Enterprise
Mock servers
Hosted mock server from a specYes:From OpenAPI documents or a GraphQL schema, with request validationNo:No mock server is documented
Mocks with your own code and stateYes:Express.js scripts from the repository (Team and Enterprise)No:No mock server is documented
Mock on your machineYes:apigit mock serve, from the working copyNo:No mock server is documented
Governance
Style rules for API descriptionsYes:Spectral: two built-in rule sets, your own on EnterprisePartly:An AI linter for the prose of guides; OpenAPI validation in its CLI
Breaking-change checkYes:apigit breaking, between two Git refs, in a terminal or in CINo:Not documented
API client and testing
API client for sending requestsPartly:Try It Out in the reference; no standalone client or saved collectionsPartly:Try It in the reference, with authenticated requests
Test scenarios, runners and monitorsNo:Not providedNo:Not provided
CLI and AI agents
Command lineYes:apigit: lint, score, diff, breaking, preview, mock and publish; the checks run offline with no accountYes:rdme uploads OpenAPI and Markdown, also as a GitHub Action
MCP serverYes:One for each published document, and one for your accountYes:An MCP server for the docs, on every plan
Plans
Free planYes:1 user, 1 published document, 1 mock serverYes:1 admin, 1 project, 1 published version, with a custom domain
First paid planYes:Team: $24 a month, 3 seats included; $8 per further seatYes: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.

Sources

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

  1. 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.

  2. 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.

  3. 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.

An exported OpenAPI file into a new repository, commands only
$ 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 push

Questions about APIGit and ReadMe

What is the main difference between APIGit and ReadMe?
ReadMe is a hosted developer hub for documentation, edited mainly in its own editor, with optional two-way sync to a Git repository. APIGit is a Git-native platform: the repository it hosts is the source, and besides publishing documentation it covers API design, governance rules and mock servers.
ReadMe has Git sync. How is APIGit different?
ReadMe keeps content in its own store and syncs it both ways with a repository on GitHub, GitLab or Bitbucket; review as pull requests happens on that host. APIGit is the Git host: the repository, its branches, the pull requests and the published versions are in the same place, and a version is a name pointing at a commit.
Does ReadMe have a mock server?
ReadMe's documentation does not describe one. APIGit serves mock servers from OpenAPI documents or a GraphQL schema, and from your own Express.js scripts on paid plans.
Does APIGit show API keys or usage metrics in the docs like ReadMe?
No. APIGit's Try It Out sends requests with the credentials a reader enters, and APIGit does not connect to your API's usage data.
How does pricing compare?
ReadMe has a free plan with one admin and one project, and Pro at $250 a month billed yearly with five admins. APIGit has a free plan for one user and per-seat Team and Enterprise plans, listed on the pricing page.

Other comparisons

Try it yourself

Worked examples from the learn hub, each with the output of the tools.

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