Open-source project
opentofu/registry avatar
opentofu/registry

opentofu/registry: adding a provider means filling in an issue form, not a pull request

Metadata and tooling for the OpenTofu registry

412 stars80 forksGoApache-2.0

At a glance

What is it?
The registry accepts provider, module, and signing key submissions through three GitHub issue templates and nothing else, because the validation pipeline depends on structured data only that form produces. Published versions are treated as immutable, so removal is a separate, higher bar request.
Who is it for?
This suits a provider or module author who wants their work in the OpenTofu namespace and who is willing to go through a human review rather than a merge. It is the wrong place to go if you want to host a private registry, if you want to remove a bad version quickly, or if your contribution is to the registry code rather than to its contents, which goes through the contributing guide instead.
Can I use it commercially?
Yes. Apache-2.0 is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository received new commits within the last day.
What is it written in?
Mainly Go, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • opentofu/registry412 ★ · +6
Star history
Repository2026-08-222026-11-15
opentofu/registry406412

6 Stars in the last 85 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

Submissions go through three issue templates, and the route is enforced

There are exactly three ways to add something, and each is a pre-filled GitHub issue rather than a pull request. A new module, a new provider, and a new provider signing key each have their own template, and each link arrives with labels and a title already set, so the only thing you do is fill in the fields.

The reason is stated as a hard requirement rather than a convention. The documentation says submissions must be made through the GitHub issue form UI using those links, and that you should not open pull requests to add registry data directly, nor create issues with the `gh` CLI, the GitHub API, or other tooling. The stated cause is that the automated validation and processing pipeline depends on the structured data that only the issue form UI provides. Anything submitted outside that form will not be processed and will be closed.

That is a defensible design and an unusual one. A registry is the kind of thing where a contributor would naturally reach for a pull request, and where automating submission with a script is genuinely convenient for a provider author publishing many versions. Both are closed off, because the validation pipeline reads the form's structured payload rather than parsing prose. The cost is that bulk submission does not work, and the benefit is that every entry arrives in a shape the tooling already understands.

After submission, a member of the OpenTofu team reviews it and either approves or denies. There is no stated SLA.

Published versions are immutable, and removal is a request with a bar to clear

Once a provider or module version is in the registry, it stays. The documentation states that published versions are treated as immutable and that the registry generally does not remove them, and it points at a version immutability section in the policy file for the detail and for the situations in which an exception may be considered.

The immutability has a straightforward justification. A lock file anywhere in the ecosystem may already reference that exact version, and a configuration that resolved cleanly yesterday can stop resolving if the artefact behind it changes or disappears. Treating published content as append only means the resolution graph is stable, which is the property a package registry exists to provide.

Removal therefore needs a separate route and a stated threshold. If your situation meets the bar described in the policy, you open a dedicated issue through a version removal request template, which is a fourth template distinct from the three submission forms. The framing is conditional: you are not requesting removal, you are asserting that your case meets the exception criteria.

For a provider author, the practical consequence is that a mistake in a published version is not something you fix by taking it down. The version stays and a corrected one goes out under a new number. The registry is not a place where you can retract something quietly, and the removal path exists for the cases where keeping it is worse than breaking the graph.

The tree separates registry data from the tooling that publishes it

The top level makes the division obvious. Three directories hold content: `providers/`, `modules/`, and `keys/`. One holds the code: `src/`. The rest are policy and process documents, and there are more of those than most projects of this kind carry.

The three content directories map directly onto the three submission templates, so a provider submission lands in `providers/`, a module submission in `modules/`, and a signing key in `keys/`. That one to one correspondence is a useful sanity check when you are trying to work out which template you actually need: a provider that publishes signed releases needs two of the three.

The policy set is unusually complete for a registry. There is a `POLICY.md` holding both the registry inclusion policy and the version immutability rules, a `PROCEDURES.md`, a `CONTRIBUTING.md` that the README asks you to read before making any contributions, and a `SECURITY.md`. The distinction the README draws is worth keeping straight: contributions to the registry codebase are a code change and go through the contributing guide, while adding data is an issue submission. They are different processes for the same repository.

Two other files do not fit the pattern. `AI-USAGE-POLICY.md` sits at the top level rather than in a directory, which suggests a policy on the use of AI tooling in contributions to this project specifically. And `versions_blacklist.json` is a machine-readable file, which is what you would expect a version filtering step to read.

Security reports are routed to a different repository entirely

If you have found a vulnerability in OpenTofu itself, the registry repository tells you to stop and go somewhere else. The instruction is to follow the security policy in the opentofu/opentofu repository, which is the main project, not the registry.

That routing is correct and worth spelling out, because the two repositories have very different trust properties. A vulnerability in the registry tooling is a supply chain problem in the narrow sense: it affects how entries get validated and published. A vulnerability in OpenTofu itself affects every configuration that runs the binary. Filing a binary issue against a metadata repository would put it in front of people who cannot act on it.

The handling commitment is specific. The project says it will send a confirmation email to acknowledge the report, and will send an additional email once the issue has been identified as either real or not real. The second email is the part that matters for anyone reporting something speculative: a report that turns out to be nothing still gets a closing response rather than silence.

The registry's own `SECURITY.md` at the root is the file that would cover the registry code itself, and the README does not spell out whether reports about registry tooling follow the same process or a separate one. That is a reasonable question to ask the maintainers if you find something in `src/`.

The hosted registry and the search site are two different front ends

The repository drives two URLs that are easy to conflate. `registry.opentofu.org` is the registry itself, and it is the thing the applications in this repository manage, specifically version bumping, validation, and API generation. `search.opentofu.org` is listed as the project homepage and is the discovery surface.

The split follows from what each is for. A registry is a protocol surface: a client resolves a provider or module address and gets back a signed artefact location, and the application generating that API has to be correct in a machine readable way. A search site is a human surface: browse providers and modules by name and read documentation. They share a data source and almost nothing else, which is why the repository tooling is described in terms of validation and API generation rather than in terms of pages.

The hosting is acknowledged in the README as well, with a note thanking Cloudflare for sponsoring a Business plan to host the registry. That is the kind of detail that becomes load bearing: a public registry is a public endpoint that infrastructure providers absorb, and a free tier would not carry it.

There is no GitHub release for the registry, which follows from the same logic. The registry has no version to release; it is a continuously generated API over data that changes as submissions are approved.

Editorial conclusion

This suits a provider or module author who wants their work in the OpenTofu namespace and who is willing to go through a human review rather than a merge. It is the wrong place to go if you want to host a private registry, if you want to remove a bad version quickly, or if your contribution is to the registry code rather than to its contents, which goes through the contributing guide instead. Before you file anything, check three things: that you are using the issue form links rather than opening a pull request or scripting the API, since submissions made any other way are closed unprocessed; that you have a GPG key submission of its own if you publish signed releases, because that is a separate template and a separate review; and whether the thing you want to publish meets the inclusion policy, which is a separate document from the submission instructions. The last push was 2026-10-01 and the repository publishes no GitHub releases, since the registry API is generated from the data rather than versioned here.

Frequently asked questions

How do I add a provider to the OpenTofu registry?

Open a GitHub issue using the Submit new Provider template link in the registry repository and fill in the required fields. The team then reviews and either approves or denies it. Pull requests adding registry data directly are not accepted.

Why does the OpenTofu registry reject submissions made with the GitHub API?

The automated validation and processing pipeline depends on the structured data that only the issue form UI provides. Submissions made through the gh CLI, the GitHub API, or other tooling will not be processed and will be closed.

Can I remove a published version from the OpenTofu registry?

Not as a matter of course. Published provider and module versions are treated as immutable and generally are not removed. If your case meets the exception bar in the version immutability policy, you can open an issue through the version removal request template.

Does adding a provider to the OpenTofu registry need a GPG key submission?

A separate submission if you publish signed releases. Provider signing keys have their own issue template and their own review, and the repository keeps them in a keys directory distinct from the providers directory.

Where do I report a security vulnerability in OpenTofu?

Not in the registry repository. The instructions point to the security policy in the opentofu/opentofu repository. The project says it sends a confirmation email on receipt and a further email once it has identified the issue as either real or not real.

Official sources

  1. Official documentation
  2. Official README
  3. Project repository
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/opentofu-registry.svg)](https://hysenlabs.com/projects/opentofu-registry)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/opentofu-registry.svg)](https://hysenlabs.com/projects/opentofu-registry)

Was this useful?