Paste `http://www.xbrl.org/2003/iso4217` into a browser address bar and see what happens. The page fails to load, or redirects to a bare specification stub that says nothing about currencies. Nothing is broken. That string underpins the unit on nearly every monetary fact in every XBRL filing on earth (it is the namespace behind measures like `iso4217:EUR`), and it was never meant to be fetched. Understanding why requires a distinction most working accountants and auditors have never had to make explicit, even though they have been typing half of it into browsers for twenty years.
A URI (Uniform Resource Identifier) is the umbrella term: any standardized string that identifies a resource, where "resource" can mean a webpage, a PDF, an API endpoint, an XBRL concept, or an abstract idea like a currency or a book. Two more specific terms live under that umbrella. A URL (Uniform Resource Locator) is a URI that also tells a client where the resource sits and how to reach it, the way `https://example.com/articles/123` names a scheme, a domain, and a path all at once. A URN (Uniform Resource Name) identifies a resource by name alone, with no promise of a location: `urn:isbn:9780140449136` picks out one specific book by its ISBN, but typing it into a browser gets you nowhere, because it was never designed to be dereferenced. Every URL is a URI. Every URN is a URI. Not every URI is a URL.
Since most everyday web addresses are URLs, that is the word people reach for by default. URI is the term you meet in formal specifications: XML, XBRL, RDF, the semantic web. The mental model worth keeping is short: a URI is an identifier, a URL is an identifier with directions attached.
When the identifier is a URL, its parts carry meaning a client actually uses. Take `https://www.example.com:443/products/shoes?id=123&color=black#reviews`. `https` is the scheme, telling the client which protocol to speak (`http`, `ftp`, `mailto`, and `file` are other schemes). `www.example.com` is the domain, which DNS translates into an IP address; `443` is the port. `/products/shoes` is the path to the resource on that server. `?id=123&color=black` is the query string, extra parameters the server reads. `#reviews` is the fragment, and it never leaves the browser: the client resolves it locally to scroll to a section of the already-loaded page, so the server never even sees it.
Namespace URIs and identifier scheme URIs are doing the URN job while wearing URL clothing. `http://www.xbrl.org/2003/iso4217` looks exactly like a fetchable address because it is built from the same syntax, but XBRL processors treat it as a globally unique name, nothing more. Two namespace strings are compared character by character: `http://example.com/ns` and `http://example.com/NS` are different identifiers even if a web server happened to serve the same page for both. The entity identifier on `xbrli:identifier` works the same way. ESEF names the issuing authority with the LEI scheme URI `http://standards.iso.org/iso/17442`, the SEC uses `http://www.sec.gov/CIK`, and Dutch SBR names it with a KvK URN, pure name-based identification with no pretense of a fetchable address at all.
Some URIs in a filing really are locations, and the difference matters operationally. `link:schemaRef` and `link:linkbaseRef` href values get dereferenced during DTS discovery: a processor genuinely retrieves those documents, whether live or from an offline taxonomy package. So the reading skill worth carrying forward is a single question, asked of every URI you meet in a filing: is this string being used as a name, or as an address? Namespaces, identifier schemes, and role and arcrole URIs are names. schemaRef and linkbaseRef targets are addresses. The syntax never tells you which; only the job does, which is exactly why the next section can say "scheme URI" without stopping to explain it twice.
A URI is the general term for any standardized string that identifies a resource; a URL and a URN are both specific kinds of URI.
A URL identifies a resource and tells a client where and how to reach it (scheme, domain, path); a URN identifies a resource by name only, with no location promised.
URL anatomy breaks into scheme, domain (resolved via DNS), port, path, query string, and fragment; the fragment is resolved by the browser and never sent to the server.
XBRL and XML namespaces use URIs purely as globally unique names: a namespace URI that returns a 404 in a browser is not a defect, and namespace comparison is exact string comparison, not case-insensitive or web-fetch based.
The entity identifier scheme on xbrli:identifier is a URI naming the issuing authority (LEI for ESEF, CIK for the SEC, a KvK URN for Dutch SBR); this is a URN-style job even where the string looks URL-shaped.
Some URIs in an XBRL filing are genuinely dereferenced as addresses, most importantly link:schemaRef and link:linkbaseRef, which DTS discovery actually retrieves; the reading skill is asking, for each URI, whether it functions as a name or as an address.
URI
(identifies a resource)
|
+--------+---------+
| |
URL URN
(identifies AND (identifies by
locates) name only)
https://example.com urn:isbn:
/articles/123 9780140449136https://www.example.com:443/products/shoes?id=123&color=black#reviews
https scheme how to access (protocol)
www.example.com domain DNS resolves it to an IP address
:443 port network port on the server
/products/shoes path which resource on that server
?id=123&color=black query extra parameters, read by the server
#reviews fragment browser-only, never sent to the server
XBRL twist: a namespace URI reuses URL syntax but does a URN's job.
http://www.xbrl.org/2003/iso4217 a NAME, never fetched
link:schemaRef href="./co-2025.xsd" an ADDRESS, actually fetched4 questions. Druk op 1 tot 4 om te kiezen, Enter om te bevestigen.
Door deze quiz af te ronden, markeer je deze sectie als voltooid.
Tip: kies met 1 tot en met 4 en bevestig met Enter.