Parse a Docker Image Reference into Registry, Repository, Tag, or Digest
Paste a Docker image reference and receive its meaningful parts as structured JSON.
Run — free
The parser separates an explicit registry, including an optional port, from the repository path and an optional tag or content digest. It understands why the colon in registry.example.com:5000 is not a tag separator and why the colon after an image name is. Malformed references fail clearly instead of producing misleading partial fields. No registry is contacted, and omitted defaults such as Docker Hub or latest are not silently invented.
Separate each part without guessing hidden defaults
A Docker image reference may be as short as alpine or as detailed as registry.example.com:5000/platform/api:2026.07. At a glance, both the registry port and the image tag use a colon, so splitting on punctuation alone gives incorrect results. This parser first isolates a digest, then examines only the final path segment for a tag. It recognizes the first slash-delimited component as an explicit registry when that component is localhost, contains a dot, contains a port colon, or is a bracketed IPv6 address. Everything after that component forms the repository path. The output preserves only what the input actually states. For alpine, the repository is alpine and there is no registry or tag field. The parser does not substitute docker.io, add the conventional library namespace, or assume latest. That behavior makes the result suitable for configuration analysis, policy checks, and migration tools where an explicit value must remain distinguishable from a client-side default.
Handle tags, digests, ports, and repository paths correctly
Tags and digests identify images in different ways. A tag is a movable label such as stable, 1.4.2, or release_candidate, while a digest is a content-addressed identifier written as an algorithm and value after an at sign. The parser returns these as separate tag and digest fields and also accepts a reference containing both, because Docker tooling can use a tagged name qualified by a digest. Repository paths may contain multiple lowercase components, with the separators permitted by familiar Docker naming rules. Registry hosts are validated separately from repository components, including numeric ports from 1 through 65535 and bracketed lowercase IPv6 forms. Digest algorithms and encoded values must follow their respective syntax, and a digest value must be long enough to be meaningful. No attempt is made to resolve a tag, verify that a digest exists, or check whether credentials permit a pull. This is syntax parsing only, so results remain deterministic, private, and available without network access.
Reject ambiguous input before it enters automation
A permissive parser can be dangerous in deployment automation because a typo may point at a different image than the operator intended. This capability rejects empty values, surrounding or embedded whitespace, URL schemes, repeated digest separators, empty path segments, malformed tags, invalid registry ports, uppercase repository names, and malformed digest expressions. It also limits the complete reference and repository length so work stays bounded. Validation returns one clear invalid input error rather than a partial object that appears trustworthy. Use that behavior at the boundary of a CI job, manifest editor, image inventory importer, or admission-policy helper. A valid result can be routed according to whether registry, tag, or digest is present, while an invalid result stops the workflow early. The parser does not claim that a syntactically valid repository or image exists; existence requires registry access and authentication, which are deliberately outside this tool. Browser execution is local, and API execution costs $0.002 per reference.
What you can do with it
Validate deployment configuration
Reject malformed image references before a manifest reaches a build, deployment, or admission-control stage.
Build an image inventory
Separate registries, repository paths, tags, and immutable digests for reporting or migration without contacting registries.
Enforce image naming policy
Inspect whether a reference uses an approved registry, a required digest, or a prohibited mutable tag.
FAQ
Does the parser add docker.io or library automatically?
No. It reports only explicit components, so an omitted registry remains omitted and the repository is preserved as written.
Does an untagged image receive the latest tag?
No. The tag field is omitted when the input has no tag. Docker client defaults are not part of the parsed text.
Can a reference contain both a tag and a digest?
Yes. When both are syntactically present, the result includes both fields instead of discarding either qualifier.
Are uppercase repository names accepted?
No. Docker repository components must be lowercase. Tags may contain uppercase characters because their syntax is different.
Does this check whether the image exists?
No. It validates and splits syntax only. It performs no registry lookup, authentication, pull, or network request.
What does API use cost?
The base price is $0.002 for each reference. The browser version runs locally without sending the reference to a registry.
For developers — API access
Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.
API endpoint
Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/dev2/docker-tag-parse \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"registry.example.com:5000/team/service:2026.07"}'const res = await fetch("https://api.kit.forhosting.com/dev2/docker-tag-parse", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "registry.example.com:5000/team/service:2026.07"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/dev2/docker-tag-parse",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "registry.example.com:5000/team/service:2026.07"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev2/docker-tag-parse", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"registry.example.com:5000/team/service:2026.07"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"registry.example.com:5000/team/service:2026.07"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev2/docker-tag-parse", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"text": "registry.example.com:5000/team/service:2026.07"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "dev2.docker_tag_parse",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.
Pricing
Published price — no tokens, no invented credits. A failed task is never charged.
Errors
| HTTP | Code | Meaning |
|---|---|---|
401 | unauthorized | Missing or invalid API key. |
402 | insufficient_balance | Your balance doesn't cover the task price. |
404 | unknown_type | That task type doesn't exist. |
429 | rate_limited | Too many requests. Use the webhook instead of polling. |