Skip to content
BranchesTags

Repository files navigation

STAC API - Language (I18N) Extension

This document is the Language (I18N) Extension to the STAC API specification, which defines how to make multi-lingual STAC APIs available.

The focus of this extension is to add API specific behavior on top of the language extension for STAC itself. So there's a STAC Language extension and a STAC API Language extension.

This specification aligns as much as possible with OGC API - Features and RFC 8288 (Web Linking).

This extension applies to all endpoints defined by the STAC API specification and STAC API extension specifications that may contain linguistic text or links to resources that may contain linguistic text.

HTTP Headers

The main mechanism for APIs to handle languages is HTTP content negotiation:

  1. The client states its language preferences in the Accept-Language header of a request. Additionally, servers can support a query parameter language.
  2. The server chooses the language that best matches one of the requested languages and the capabilities of the server. The response
    • contains linguistic text in the chosen language, and
    • informs the client of the choice with the Content-Language header.

Generally, each language identifier MUST be a valid Language-Tag as specified in RFC 5646.

Example:

GET / HTTP/2Host: stac-api.example.comAccept: application/json,text/json,application/geo+json;q=0.9Accept-Language: de-DE,de;q=0.9,en-US;q=0.8,en;q=0.7,fr;q=0.3

Query Parameter

In addition to the header-based approach, servers MAY support a query parameter language.

If provided, the language query parameter MUST be at least valid Language-Tag as specified in RFC 5646. The query parameter follows the exact same schema as the Accept-Language header, so you can define a list of prioritized languages, e.g. de-DE,de;q=0.9,en-US;q=0.8,en;q=0.7,fr;q=0.3.

Example:

GET /?language=de HTTP/2Host: stac-api.example.com

Note: If both the header Accept-Language and the query parameter language are provided by a client, it is recommended to use the values provided in the query parameter. This is recommended to avoid issues with some clients (such as a web browser) that may send headers that are not under control of a user. Ultimately, it's up to the implementation to decide which source it prioritizes.

Response Body

The response body SHOULD inform clients about the language of the resource and any resource it links to. For this, it implements the STAC language extension.

Example

This example request and response is based on the example landing page for STAC API - Core and shows the usage of this extension.

Header:

HTTP/2 200 OKServer: stac-api.example.comVary: Accept, Accept-LanguageContent-Type: application/json; charset=utf-8Content-Language: en-US

Body

{
"stac_version": "1.0.0",
"stac_extensions": [
"https://stac-extensions.github.io/language/v1.0.0/schema.json"
],
"id": "example-stac",
"title": "A simple STAC API Example",
"description": "This Catalog aims to demonstrate the a simple landing page",
"type": "Catalog",
"language": {
"code": "en-US",
"name": "English (United States)"
},
"languages": [
{
"code": "de",
"name": "Deutsch",
"alternate": "German"
}
],
"conformsTo" : [
"https://api.stacspec.org/v1.0.0-rc.2/core",
"https://api.stacspec.org/v1.0.0-rc.2/language"
],
"links": [
{
"rel": "self",
"type": "application/json",
"href": "https://stac-api.example.com",
"hreflang": "en-US"
},
{
"rel": "root",
"type": "application/json",
"href": "https://stac-api.example.com",
"hreflang": "en-US"
},
{
"rel": "service-desc",
"type": "application/vnd.oai.openapi+json;version=3.0",
"href": "https://example.com/api",
"hreflang": "en"
},
{
"rel": "service-doc",
"type": "text/html",
"href": "https://example.com/api.html",
"hreflang": "en-US"
},
{
"rel": "service-doc",
"type": "text/html",
"href": "https://example.com/de/api.html",
"hreflang": "de"
},
{
"rel": "alternate",
"type": "application/json",
"href": "https://example.com/?language=de",
"hreflang": "de"
}
]
}

About

Definitions and recommendations around making multi-lingual STAC APIs available

Resources

Readme
Apache-2.0 license
Activity
Custom properties

Stars

1 star

Watchers

3 watching

Forks

1 fork
Report repository

Releases

Packages

Used by

Contributors

, 'i'); if (__m === '*' || __re.test(location.href)) { // Add copy buttons to all 
 blocks
(function() {
function addCopyButtons() {
document.querySelectorAll('pre code').forEach(function(codeBlock) {
if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;
codeBlock.parentElement.setAttribute('data-copy-added', 'true');
var btn = document.createElement('button');
btn.textContent = 'Copy';
btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';
btn.onmouseover = function() { this.style.opacity = '1'; };
btn.onmouseout = function() { this.style.opacity = '0.7'; };
btn.onclick = function() {
navigator.clipboard.writeText(codeBlock.textContent).then(function() {
btn.textContent = 'Copied!';
setTimeout(function() { btn.textContent = 'Copy'; }, 1500);
});
};
codeBlock.parentElement.style.position = 'relative';
codeBlock.parentElement.appendChild(btn);
});
}
addCopyButtons();
// Re-run on dynamic content
var observer = new MutationObserver(addCopyButtons);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '
GitHub - stac-api-extensions/language: Definitions and recommendations around making multi-lingual STAC APIs available · GitHub
Skip to content
BranchesTags
Repository files navigation
STAC API - Language (I18N) Extension
This document is the Language (I18N) Extension to the
STAC API specification,
which defines how to make multi-lingual STAC APIs available.
The focus of this extension is to add API specific behavior on top of the
language extension for STAC itself.
So there's a STAC Language extension and a STAC API Language extension.
This specification aligns as much as possible with
OGC API - Features and
RFC 8288 (Web Linking).
This extension applies to all endpoints defined by the STAC API specification and STAC API extension specifications
that may contain linguistic text or links to resources that may contain linguistic text.
HTTP Headers
The main mechanism for APIs to handle languages is
HTTP content negotiation:
  1. The client states its language preferences in the
Accept-Language header of a request.
Additionally, servers can support a query parameter language.
  2. The server chooses the language that best matches one of the requested languages and the capabilities of the server.
The response

    • contains linguistic text in the chosen language, and
    • informs the client of the choice with the Content-Language header.
Generally, each language identifier MUST be a valid Language-Tag as specified in RFC 5646.
Example:
GET / HTTP/2Host: stac-api.example.comAccept: application/json,text/json,application/geo+json;q=0.9Accept-Language: de-DE,de;q=0.9,en-US;q=0.8,en;q=0.7,fr;q=0.3
Query Parameter
In addition to the header-based approach, servers MAY support a query parameter language.
If provided, the language query parameter MUST be at least valid Language-Tag as specified in RFC 5646.
The query parameter follows the exact same schema as the Accept-Language header,
so you can define a list of prioritized languages, e.g. de-DE,de;q=0.9,en-US;q=0.8,en;q=0.7,fr;q=0.3.
Example:
GET /?language=de HTTP/2Host: stac-api.example.com
Note: If both the header Accept-Language and the query parameter language are provided by a client,
it is recommended to use the values provided in the query parameter.
This is recommended to avoid issues with some clients (such as a web browser) that may send headers
that are not under control of a user.
Ultimately, it's up to the implementation to decide which source it prioritizes.
Response Body
The response body SHOULD inform clients about the language of the resource and any resource it links to.
For this, it implements the STAC language extension.
Example
This example request and response is based on the
example landing page for STAC API - Core
and shows the usage of this extension.
Header:
HTTP/2 200 OKServer: stac-api.example.comVary: Accept, Accept-LanguageContent-Type: application/json; charset=utf-8Content-Language: en-US
Body
{
"stac_version": "1.0.0",
"stac_extensions": [
"https://stac-extensions.github.io/language/v1.0.0/schema.json"
],
"id": "example-stac",
"title": "A simple STAC API Example",
"description": "This Catalog aims to demonstrate the a simple landing page",
"type": "Catalog",
"language": {
"code": "en-US",
"name": "English (United States)"
},
"languages": [
{
"code": "de",
"name": "Deutsch",
"alternate": "German"
}
],
"conformsTo" : [
"https://api.stacspec.org/v1.0.0-rc.2/core",
"https://api.stacspec.org/v1.0.0-rc.2/language"
],
"links": [
{
"rel": "self",
"type": "application/json",
"href": "https://stac-api.example.com",
"hreflang": "en-US"
},
{
"rel": "root",
"type": "application/json",
"href": "https://stac-api.example.com",
"hreflang": "en-US"
},
{
"rel": "service-desc",
"type": "application/vnd.oai.openapi+json;version=3.0",
"href": "https://example.com/api",
"hreflang": "en"
},
{
"rel": "service-doc",
"type": "text/html",
"href": "https://example.com/api.html",
"hreflang": "en-US"
},
{
"rel": "service-doc",
"type": "text/html",
"href": "https://example.com/de/api.html",
"hreflang": "de"
},
{
"rel": "alternate",
"type": "application/json",
"href": "https://example.com/?language=de",
"hreflang": "de"
}
]
}
About
Definitions and recommendations around making multi-lingual STAC APIs available
Resources
Readme
Apache-2.0 license
Activity
Custom properties
Stars
1 star
Watchers
3 watching
Forks
1 fork
Report repository
Releases
Packages
Used by
Contributors

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Force GitHub README to respect dark mode
(function() {
var style = document.createElement('style');
style.textContent = '
.markdown-body {
color-scheme: dark light;
}
.markdown-body pre { background: #161b22 !important; }
.markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }
.markdown-body table th, .markdown-body table td { border-color: #30363d !important; }
.markdown-body img { background: #0d1117; }
.markdown-body blockquote { border-left-color: #8b949e; }
.markdown-body hr { border-color: #30363d; }
';
document.head.appendChild(style);
})();
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - stac-api-extensions/language: Definitions and recommendations around making multi-lingual STAC APIs available · GitHub
Skip to content
BranchesTags
Repository files navigation
STAC API - Language (I18N) Extension
This document is the Language (I18N) Extension to the
STAC API specification,
which defines how to make multi-lingual STAC APIs available.
The focus of this extension is to add API specific behavior on top of the
language extension for STAC itself.
So there's a STAC Language extension and a STAC API Language extension.
This specification aligns as much as possible with
OGC API - Features and
RFC 8288 (Web Linking).
This extension applies to all endpoints defined by the STAC API specification and STAC API extension specifications
that may contain linguistic text or links to resources that may contain linguistic text.
HTTP Headers
The main mechanism for APIs to handle languages is
HTTP content negotiation:
  1. The client states its language preferences in the
Accept-Language header of a request.
Additionally, servers can support a query parameter language.
  2. The server chooses the language that best matches one of the requested languages and the capabilities of the server.
The response

    • contains linguistic text in the chosen language, and
    • informs the client of the choice with the Content-Language header.
Generally, each language identifier MUST be a valid Language-Tag as specified in RFC 5646.
Example:
GET / HTTP/2Host: stac-api.example.comAccept: application/json,text/json,application/geo+json;q=0.9Accept-Language: de-DE,de;q=0.9,en-US;q=0.8,en;q=0.7,fr;q=0.3
Query Parameter
In addition to the header-based approach, servers MAY support a query parameter language.
If provided, the language query parameter MUST be at least valid Language-Tag as specified in RFC 5646.
The query parameter follows the exact same schema as the Accept-Language header,
so you can define a list of prioritized languages, e.g. de-DE,de;q=0.9,en-US;q=0.8,en;q=0.7,fr;q=0.3.
Example:
GET /?language=de HTTP/2Host: stac-api.example.com
Note: If both the header Accept-Language and the query parameter language are provided by a client,
it is recommended to use the values provided in the query parameter.
This is recommended to avoid issues with some clients (such as a web browser) that may send headers
that are not under control of a user.
Ultimately, it's up to the implementation to decide which source it prioritizes.
Response Body
The response body SHOULD inform clients about the language of the resource and any resource it links to.
For this, it implements the STAC language extension.
Example
This example request and response is based on the
example landing page for STAC API - Core
and shows the usage of this extension.
Header:
HTTP/2 200 OKServer: stac-api.example.comVary: Accept, Accept-LanguageContent-Type: application/json; charset=utf-8Content-Language: en-US
Body
{
"stac_version": "1.0.0",
"stac_extensions": [
"https://stac-extensions.github.io/language/v1.0.0/schema.json"
],
"id": "example-stac",
"title": "A simple STAC API Example",
"description": "This Catalog aims to demonstrate the a simple landing page",
"type": "Catalog",
"language": {
"code": "en-US",
"name": "English (United States)"
},
"languages": [
{
"code": "de",
"name": "Deutsch",
"alternate": "German"
}
],
"conformsTo" : [
"https://api.stacspec.org/v1.0.0-rc.2/core",
"https://api.stacspec.org/v1.0.0-rc.2/language"
],
"links": [
{
"rel": "self",
"type": "application/json",
"href": "https://stac-api.example.com",
"hreflang": "en-US"
},
{
"rel": "root",
"type": "application/json",
"href": "https://stac-api.example.com",
"hreflang": "en-US"
},
{
"rel": "service-desc",
"type": "application/vnd.oai.openapi+json;version=3.0",
"href": "https://example.com/api",
"hreflang": "en"
},
{
"rel": "service-doc",
"type": "text/html",
"href": "https://example.com/api.html",
"hreflang": "en-US"
},
{
"rel": "service-doc",
"type": "text/html",
"href": "https://example.com/de/api.html",
"hreflang": "de"
},
{
"rel": "alternate",
"type": "application/json",
"href": "https://example.com/?language=de",
"hreflang": "de"
}
]
}
About
Definitions and recommendations around making multi-lingual STAC APIs available
Resources
Readme
Apache-2.0 license
Activity
Custom properties
Stars
1 star
Watchers
3 watching
Forks
1 fork
Report repository
Releases
Packages
Used by
Contributors

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Highlight search terms from Google/DuckDuckGo/Bing referrer
(function() {
var ref = document.referrer;
var terms = [];
if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {
var url = new URL(ref);
var q = url.searchParams.get('q') || url.searchParams.get('p');
if (q) {
terms = q.split(/\s+/).filter(function(t) { return t.length > 2; });
}
}
if (terms.length === 0) return;
var style = document.createElement('style');
style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';
document.head.appendChild(style);
function highlight(node) {
if (node.nodeType === 3) { // text node
var text = node.textContent;
var found = false;
terms.forEach(function(term) {
var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\]\\]/g, '\\') + ')', 'gi');
if (regex.test(text)) {
found = true;
var frag = document.createDocumentFragment();
var parts = text.split(regex);
parts.forEach(function(part, i) {
if (i % 2 === 0) {
frag.appendChild(document.createTextNode(part));
} else {
var span = document.createElement('span');
span.className = 'userscript-highlight';
span.textContent = part;
frag.appendChild(span);
}
});
node.parentNode.replaceChild(frag, node);
}
});
} else if (node.nodeType === 1 && node.childNodes) { // element
var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];
if (!skipTags.includes(node.tagName)) {
Array.from(node.childNodes).forEach(highlight);
}
}
}
highlight(document.body);
// Re-highlight on dynamic content
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1 || node.nodeType === 3) highlight(node);
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - stac-api-extensions/language: Definitions and recommendations around making multi-lingual STAC APIs available · GitHub
Skip to content
BranchesTags
Repository files navigation
STAC API - Language (I18N) Extension
This document is the Language (I18N) Extension to the
STAC API specification,
which defines how to make multi-lingual STAC APIs available.
The focus of this extension is to add API specific behavior on top of the
language extension for STAC itself.
So there's a STAC Language extension and a STAC API Language extension.
This specification aligns as much as possible with
OGC API - Features and
RFC 8288 (Web Linking).
This extension applies to all endpoints defined by the STAC API specification and STAC API extension specifications
that may contain linguistic text or links to resources that may contain linguistic text.
HTTP Headers
The main mechanism for APIs to handle languages is
HTTP content negotiation:
  1. The client states its language preferences in the
Accept-Language header of a request.
Additionally, servers can support a query parameter language.
  2. The server chooses the language that best matches one of the requested languages and the capabilities of the server.
The response

    • contains linguistic text in the chosen language, and
    • informs the client of the choice with the Content-Language header.
Generally, each language identifier MUST be a valid Language-Tag as specified in RFC 5646.
Example:
GET / HTTP/2Host: stac-api.example.comAccept: application/json,text/json,application/geo+json;q=0.9Accept-Language: de-DE,de;q=0.9,en-US;q=0.8,en;q=0.7,fr;q=0.3
Query Parameter
In addition to the header-based approach, servers MAY support a query parameter language.
If provided, the language query parameter MUST be at least valid Language-Tag as specified in RFC 5646.
The query parameter follows the exact same schema as the Accept-Language header,
so you can define a list of prioritized languages, e.g. de-DE,de;q=0.9,en-US;q=0.8,en;q=0.7,fr;q=0.3.
Example:
GET /?language=de HTTP/2Host: stac-api.example.com
Note: If both the header Accept-Language and the query parameter language are provided by a client,
it is recommended to use the values provided in the query parameter.
This is recommended to avoid issues with some clients (such as a web browser) that may send headers
that are not under control of a user.
Ultimately, it's up to the implementation to decide which source it prioritizes.
Response Body
The response body SHOULD inform clients about the language of the resource and any resource it links to.
For this, it implements the STAC language extension.
Example
This example request and response is based on the
example landing page for STAC API - Core
and shows the usage of this extension.
Header:
HTTP/2 200 OKServer: stac-api.example.comVary: Accept, Accept-LanguageContent-Type: application/json; charset=utf-8Content-Language: en-US
Body
{
"stac_version": "1.0.0",
"stac_extensions": [
"https://stac-extensions.github.io/language/v1.0.0/schema.json"
],
"id": "example-stac",
"title": "A simple STAC API Example",
"description": "This Catalog aims to demonstrate the a simple landing page",
"type": "Catalog",
"language": {
"code": "en-US",
"name": "English (United States)"
},
"languages": [
{
"code": "de",
"name": "Deutsch",
"alternate": "German"
}
],
"conformsTo" : [
"https://api.stacspec.org/v1.0.0-rc.2/core",
"https://api.stacspec.org/v1.0.0-rc.2/language"
],
"links": [
{
"rel": "self",
"type": "application/json",
"href": "https://stac-api.example.com",
"hreflang": "en-US"
},
{
"rel": "root",
"type": "application/json",
"href": "https://stac-api.example.com",
"hreflang": "en-US"
},
{
"rel": "service-desc",
"type": "application/vnd.oai.openapi+json;version=3.0",
"href": "https://example.com/api",
"hreflang": "en"
},
{
"rel": "service-doc",
"type": "text/html",
"href": "https://example.com/api.html",
"hreflang": "en-US"
},
{
"rel": "service-doc",
"type": "text/html",
"href": "https://example.com/de/api.html",
"hreflang": "de"
},
{
"rel": "alternate",
"type": "application/json",
"href": "https://example.com/?language=de",
"hreflang": "de"
}
]
}
About
Definitions and recommendations around making multi-lingual STAC APIs available
Resources
Readme
Apache-2.0 license
Activity
Custom properties
Stars
1 star
Watchers
3 watching
Forks
1 fork
Report repository
Releases
Packages
Used by
Contributors

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Strip utm_, fbclid, gclid, etc. from all links on page
(function() {
var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',
'ref', 'ref_src', 'source', 'medium', 'campaign'];
function cleanUrl(url) {
try {
var u = new URL(url, window.location.origin);
var changed = false;
trackingParams.forEach(function(p) {
if (u.searchParams.has(p)) {
u.searchParams.delete(p);
changed = true;
}
});
return changed ? u.toString() : url;
} catch (e) {
return url;
}
}
function cleanLinks() {
document.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
cleanLinks();
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1) {
if (node.tagName === 'A') cleanLinks();
node.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '
GitHub - stac-api-extensions/language: Definitions and recommendations around making multi-lingual STAC APIs available · GitHub
Skip to content
BranchesTags
Repository files navigation
STAC API - Language (I18N) Extension
This document is the Language (I18N) Extension to the
STAC API specification,
which defines how to make multi-lingual STAC APIs available.
The focus of this extension is to add API specific behavior on top of the
language extension for STAC itself.
So there's a STAC Language extension and a STAC API Language extension.
This specification aligns as much as possible with
OGC API - Features and
RFC 8288 (Web Linking).
This extension applies to all endpoints defined by the STAC API specification and STAC API extension specifications
that may contain linguistic text or links to resources that may contain linguistic text.
HTTP Headers
The main mechanism for APIs to handle languages is
HTTP content negotiation:
  1. The client states its language preferences in the
Accept-Language header of a request.
Additionally, servers can support a query parameter language.
  2. The server chooses the language that best matches one of the requested languages and the capabilities of the server.
The response

    • contains linguistic text in the chosen language, and
    • informs the client of the choice with the Content-Language header.
Generally, each language identifier MUST be a valid Language-Tag as specified in RFC 5646.
Example:
GET / HTTP/2Host: stac-api.example.comAccept: application/json,text/json,application/geo+json;q=0.9Accept-Language: de-DE,de;q=0.9,en-US;q=0.8,en;q=0.7,fr;q=0.3
Query Parameter
In addition to the header-based approach, servers MAY support a query parameter language.
If provided, the language query parameter MUST be at least valid Language-Tag as specified in RFC 5646.
The query parameter follows the exact same schema as the Accept-Language header,
so you can define a list of prioritized languages, e.g. de-DE,de;q=0.9,en-US;q=0.8,en;q=0.7,fr;q=0.3.
Example:
GET /?language=de HTTP/2Host: stac-api.example.com
Note: If both the header Accept-Language and the query parameter language are provided by a client,
it is recommended to use the values provided in the query parameter.
This is recommended to avoid issues with some clients (such as a web browser) that may send headers
that are not under control of a user.
Ultimately, it's up to the implementation to decide which source it prioritizes.
Response Body
The response body SHOULD inform clients about the language of the resource and any resource it links to.
For this, it implements the STAC language extension.
Example
This example request and response is based on the
example landing page for STAC API - Core
and shows the usage of this extension.
Header:
HTTP/2 200 OKServer: stac-api.example.comVary: Accept, Accept-LanguageContent-Type: application/json; charset=utf-8Content-Language: en-US
Body
{
"stac_version": "1.0.0",
"stac_extensions": [
"https://stac-extensions.github.io/language/v1.0.0/schema.json"
],
"id": "example-stac",
"title": "A simple STAC API Example",
"description": "This Catalog aims to demonstrate the a simple landing page",
"type": "Catalog",
"language": {
"code": "en-US",
"name": "English (United States)"
},
"languages": [
{
"code": "de",
"name": "Deutsch",
"alternate": "German"
}
],
"conformsTo" : [
"https://api.stacspec.org/v1.0.0-rc.2/core",
"https://api.stacspec.org/v1.0.0-rc.2/language"
],
"links": [
{
"rel": "self",
"type": "application/json",
"href": "https://stac-api.example.com",
"hreflang": "en-US"
},
{
"rel": "root",
"type": "application/json",
"href": "https://stac-api.example.com",
"hreflang": "en-US"
},
{
"rel": "service-desc",
"type": "application/vnd.oai.openapi+json;version=3.0",
"href": "https://example.com/api",
"hreflang": "en"
},
{
"rel": "service-doc",
"type": "text/html",
"href": "https://example.com/api.html",
"hreflang": "en-US"
},
{
"rel": "service-doc",
"type": "text/html",
"href": "https://example.com/de/api.html",
"hreflang": "de"
},
{
"rel": "alternate",
"type": "application/json",
"href": "https://example.com/?language=de",
"hreflang": "de"
}
]
}
About
Definitions and recommendations around making multi-lingual STAC APIs available
Resources
Readme
Apache-2.0 license
Activity
Custom properties
Stars
1 star
Watchers
3 watching
Forks
1 fork
Report repository
Releases
Packages
Used by
Contributors

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Auto-enable theater mode on YouTube
(function() {
function tryTheater() {
var btn = document.querySelector('button[aria-label="Theater mode"], ytd-player #player button[title="Theater mode"]');
if (btn && !btn.classList.contains('activated')) {
btn.click();
}
}
// Try immediately
tryTheater();
// Try after navigation (SPA)
var lastUrl = location.href;
setInterval(function() {
if (location.href !== lastUrl) {
lastUrl = location.href;
setTimeout(tryTheater, 500);
}
}, 1000);
// Also try on player load
var observer = new MutationObserver(tryTheater);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - stac-api-extensions/language: Definitions and recommendations around making multi-lingual STAC APIs available · GitHub
Skip to content
BranchesTags
Repository files navigation
STAC API - Language (I18N) Extension
This document is the Language (I18N) Extension to the
STAC API specification,
which defines how to make multi-lingual STAC APIs available.
The focus of this extension is to add API specific behavior on top of the
language extension for STAC itself.
So there's a STAC Language extension and a STAC API Language extension.
This specification aligns as much as possible with
OGC API - Features and
RFC 8288 (Web Linking).
This extension applies to all endpoints defined by the STAC API specification and STAC API extension specifications
that may contain linguistic text or links to resources that may contain linguistic text.
HTTP Headers
The main mechanism for APIs to handle languages is
HTTP content negotiation:
  1. The client states its language preferences in the
Accept-Language header of a request.
Additionally, servers can support a query parameter language.
  2. The server chooses the language that best matches one of the requested languages and the capabilities of the server.
The response

    • contains linguistic text in the chosen language, and
    • informs the client of the choice with the Content-Language header.
Generally, each language identifier MUST be a valid Language-Tag as specified in RFC 5646.
Example:
GET / HTTP/2Host: stac-api.example.comAccept: application/json,text/json,application/geo+json;q=0.9Accept-Language: de-DE,de;q=0.9,en-US;q=0.8,en;q=0.7,fr;q=0.3
Query Parameter
In addition to the header-based approach, servers MAY support a query parameter language.
If provided, the language query parameter MUST be at least valid Language-Tag as specified in RFC 5646.
The query parameter follows the exact same schema as the Accept-Language header,
so you can define a list of prioritized languages, e.g. de-DE,de;q=0.9,en-US;q=0.8,en;q=0.7,fr;q=0.3.
Example:
GET /?language=de HTTP/2Host: stac-api.example.com
Note: If both the header Accept-Language and the query parameter language are provided by a client,
it is recommended to use the values provided in the query parameter.
This is recommended to avoid issues with some clients (such as a web browser) that may send headers
that are not under control of a user.
Ultimately, it's up to the implementation to decide which source it prioritizes.
Response Body
The response body SHOULD inform clients about the language of the resource and any resource it links to.
For this, it implements the STAC language extension.
Example
This example request and response is based on the
example landing page for STAC API - Core
and shows the usage of this extension.
Header:
HTTP/2 200 OKServer: stac-api.example.comVary: Accept, Accept-LanguageContent-Type: application/json; charset=utf-8Content-Language: en-US
Body
{
"stac_version": "1.0.0",
"stac_extensions": [
"https://stac-extensions.github.io/language/v1.0.0/schema.json"
],
"id": "example-stac",
"title": "A simple STAC API Example",
"description": "This Catalog aims to demonstrate the a simple landing page",
"type": "Catalog",
"language": {
"code": "en-US",
"name": "English (United States)"
},
"languages": [
{
"code": "de",
"name": "Deutsch",
"alternate": "German"
}
],
"conformsTo" : [
"https://api.stacspec.org/v1.0.0-rc.2/core",
"https://api.stacspec.org/v1.0.0-rc.2/language"
],
"links": [
{
"rel": "self",
"type": "application/json",
"href": "https://stac-api.example.com",
"hreflang": "en-US"
},
{
"rel": "root",
"type": "application/json",
"href": "https://stac-api.example.com",
"hreflang": "en-US"
},
{
"rel": "service-desc",
"type": "application/vnd.oai.openapi+json;version=3.0",
"href": "https://example.com/api",
"hreflang": "en"
},
{
"rel": "service-doc",
"type": "text/html",
"href": "https://example.com/api.html",
"hreflang": "en-US"
},
{
"rel": "service-doc",
"type": "text/html",
"href": "https://example.com/de/api.html",
"hreflang": "de"
},
{
"rel": "alternate",
"type": "application/json",
"href": "https://example.com/?language=de",
"hreflang": "de"
}
]
}
About
Definitions and recommendations around making multi-lingual STAC APIs available
Resources
Readme
Apache-2.0 license
Activity
Custom properties
Stars
1 star
Watchers
3 watching
Forks
1 fork
Report repository
Releases
Packages
Used by
Contributors

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Remove or un-stick sticky/fixed headers that block content
(function() {
function unstick() {
document.querySelectorAll('header, nav, [role="banner"], .header, .navbar, .sticky, .fixed-top, [style*="position: fixed"], [style*="position:sticky"]').forEach(function(el) {
if (el.style.position === 'fixed' || el.style.position === 'sticky' || getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {
el.style.position = 'static';
el.style.top = 'auto';
el.style.zIndex = 'auto';
}
});
}
unstick();
var observer = new MutationObserver(unstick);
observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });
})();
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - stac-api-extensions/language: Definitions and recommendations around making multi-lingual STAC APIs available · GitHub
Skip to content
BranchesTags
Repository files navigation
STAC API - Language (I18N) Extension
This document is the Language (I18N) Extension to the
STAC API specification,
which defines how to make multi-lingual STAC APIs available.
The focus of this extension is to add API specific behavior on top of the
language extension for STAC itself.
So there's a STAC Language extension and a STAC API Language extension.
This specification aligns as much as possible with
OGC API - Features and
RFC 8288 (Web Linking).
This extension applies to all endpoints defined by the STAC API specification and STAC API extension specifications
that may contain linguistic text or links to resources that may contain linguistic text.
HTTP Headers
The main mechanism for APIs to handle languages is
HTTP content negotiation:
  1. The client states its language preferences in the
Accept-Language header of a request.
Additionally, servers can support a query parameter language.
  2. The server chooses the language that best matches one of the requested languages and the capabilities of the server.
The response

    • contains linguistic text in the chosen language, and
    • informs the client of the choice with the Content-Language header.
Generally, each language identifier MUST be a valid Language-Tag as specified in RFC 5646.
Example:
GET / HTTP/2Host: stac-api.example.comAccept: application/json,text/json,application/geo+json;q=0.9Accept-Language: de-DE,de;q=0.9,en-US;q=0.8,en;q=0.7,fr;q=0.3
Query Parameter
In addition to the header-based approach, servers MAY support a query parameter language.
If provided, the language query parameter MUST be at least valid Language-Tag as specified in RFC 5646.
The query parameter follows the exact same schema as the Accept-Language header,
so you can define a list of prioritized languages, e.g. de-DE,de;q=0.9,en-US;q=0.8,en;q=0.7,fr;q=0.3.
Example:
GET /?language=de HTTP/2Host: stac-api.example.com
Note: If both the header Accept-Language and the query parameter language are provided by a client,
it is recommended to use the values provided in the query parameter.
This is recommended to avoid issues with some clients (such as a web browser) that may send headers
that are not under control of a user.
Ultimately, it's up to the implementation to decide which source it prioritizes.
Response Body
The response body SHOULD inform clients about the language of the resource and any resource it links to.
For this, it implements the STAC language extension.
Example
This example request and response is based on the
example landing page for STAC API - Core
and shows the usage of this extension.
Header:
HTTP/2 200 OKServer: stac-api.example.comVary: Accept, Accept-LanguageContent-Type: application/json; charset=utf-8Content-Language: en-US
Body
{
"stac_version": "1.0.0",
"stac_extensions": [
"https://stac-extensions.github.io/language/v1.0.0/schema.json"
],
"id": "example-stac",
"title": "A simple STAC API Example",
"description": "This Catalog aims to demonstrate the a simple landing page",
"type": "Catalog",
"language": {
"code": "en-US",
"name": "English (United States)"
},
"languages": [
{
"code": "de",
"name": "Deutsch",
"alternate": "German"
}
],
"conformsTo" : [
"https://api.stacspec.org/v1.0.0-rc.2/core",
"https://api.stacspec.org/v1.0.0-rc.2/language"
],
"links": [
{
"rel": "self",
"type": "application/json",
"href": "https://stac-api.example.com",
"hreflang": "en-US"
},
{
"rel": "root",
"type": "application/json",
"href": "https://stac-api.example.com",
"hreflang": "en-US"
},
{
"rel": "service-desc",
"type": "application/vnd.oai.openapi+json;version=3.0",
"href": "https://example.com/api",
"hreflang": "en"
},
{
"rel": "service-doc",
"type": "text/html",
"href": "https://example.com/api.html",
"hreflang": "en-US"
},
{
"rel": "service-doc",
"type": "text/html",
"href": "https://example.com/de/api.html",
"hreflang": "de"
},
{
"rel": "alternate",
"type": "application/json",
"href": "https://example.com/?language=de",
"hreflang": "de"
}
]
}
About
Definitions and recommendations around making multi-lingual STAC APIs available
Resources
Readme
Apache-2.0 license
Activity
Custom properties
Stars
1 star
Watchers
3 watching
Forks
1 fork
Report repository
Releases
Packages
Used by
Contributors

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Universal Dark Mode - works on any site
(function() {
var enabled = true;
function applyDarkMode() {
if (!enabled) return;
// Create style element if it doesn't exist
var style = document.getElementById('universal-dark-mode-style');
if (!style) {
style = document.createElement('style');
style.id = 'universal-dark-mode-style';
document.head.appendChild(style);
}
// Dark mode CSS - inverts colors but preserves images/video
style.textContent = '
/* Invert everything except media */
html {
filter: invert(1) hue-rotate(180deg) !important;
background: #1a1a2e !important;
}
/* Restore images, videos, iframes, canvas */
img, video, iframe, canvas, svg, picture, [style*="background-image"] {
filter: invert(1) hue-rotate(180deg) !important;
}
/* Preserve specific elements that should not be inverted */
.no-dark-mode, .no-dark-mode *,
[data-theme="light"], [data-theme="light"],
.ace_editor, .ace_editor *,
.CodeMirror, .CodeMirror *,
.monaco-editor, .monaco-editor *,
.markdown-body pre, .markdown-body pre *,
.highlight, .highlight *,
pre code, pre code * {
filter: none !important;
}
/* Fix common UI elements */
.modal, .popup, .dropdown-menu, .tooltip, .popover {
filter: invert(1) hue-rotate(180deg) !important;
background: #2d2d44 !important;
border-color: #444 !important;
}
/* Scrollbars */
::-webkit-scrollbar { background: #1a1a2e !important; }
::-webkit-scrollbar-thumb { background: #444 !important; }
::-webkit-scrollbar-thumb:hover { background: #555 !important; }
/* Selection */
::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
';
}
function removeDarkMode() {
var style = document.getElementById('universal-dark-mode-style');
if (style) style.remove();
}
// Toggle with Alt+Shift+D
document.addEventListener('keydown', function(e) {
if (e.altKey && e.shiftKey && e.key === 'D') {
e.preventDefault();
enabled = !enabled;
if (enabled) {
applyDarkMode();
console.log('[Universal Dark Mode] Enabled');
} else {
removeDarkMode();
console.log('[Universal Dark Mode] Disabled');
}
}
});
// Apply on load
applyDarkMode();
// Re-apply on dynamic content
var observer = new MutationObserver(function(mutations) {
if (enabled && !document.getElementById('universal-dark-mode-style')) {
applyDarkMode();
}
});
observer.observe(document.head, { childList: true });
console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');
})();
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();
GitHub - stac-api-extensions/language: Definitions and recommendations around making multi-lingual STAC APIs available · GitHub
Skip to content
BranchesTags
Repository files navigation
STAC API - Language (I18N) Extension
This document is the Language (I18N) Extension to the
STAC API specification,
which defines how to make multi-lingual STAC APIs available.
The focus of this extension is to add API specific behavior on top of the
language extension for STAC itself.
So there's a STAC Language extension and a STAC API Language extension.
This specification aligns as much as possible with
OGC API - Features and
RFC 8288 (Web Linking).
This extension applies to all endpoints defined by the STAC API specification and STAC API extension specifications
that may contain linguistic text or links to resources that may contain linguistic text.
HTTP Headers
The main mechanism for APIs to handle languages is
HTTP content negotiation:
  1. The client states its language preferences in the
Accept-Language header of a request.
Additionally, servers can support a query parameter language.
  2. The server chooses the language that best matches one of the requested languages and the capabilities of the server.
The response

    • contains linguistic text in the chosen language, and
    • informs the client of the choice with the Content-Language header.
Generally, each language identifier MUST be a valid Language-Tag as specified in RFC 5646.
Example:
GET / HTTP/2Host: stac-api.example.comAccept: application/json,text/json,application/geo+json;q=0.9Accept-Language: de-DE,de;q=0.9,en-US;q=0.8,en;q=0.7,fr;q=0.3
Query Parameter
In addition to the header-based approach, servers MAY support a query parameter language.
If provided, the language query parameter MUST be at least valid Language-Tag as specified in RFC 5646.
The query parameter follows the exact same schema as the Accept-Language header,
so you can define a list of prioritized languages, e.g. de-DE,de;q=0.9,en-US;q=0.8,en;q=0.7,fr;q=0.3.
Example:
GET /?language=de HTTP/2Host: stac-api.example.com
Note: If both the header Accept-Language and the query parameter language are provided by a client,
it is recommended to use the values provided in the query parameter.
This is recommended to avoid issues with some clients (such as a web browser) that may send headers
that are not under control of a user.
Ultimately, it's up to the implementation to decide which source it prioritizes.
Response Body
The response body SHOULD inform clients about the language of the resource and any resource it links to.
For this, it implements the STAC language extension.
Example
This example request and response is based on the
example landing page for STAC API - Core
and shows the usage of this extension.
Header:
HTTP/2 200 OKServer: stac-api.example.comVary: Accept, Accept-LanguageContent-Type: application/json; charset=utf-8Content-Language: en-US
Body
{
"stac_version": "1.0.0",
"stac_extensions": [
"https://stac-extensions.github.io/language/v1.0.0/schema.json"
],
"id": "example-stac",
"title": "A simple STAC API Example",
"description": "This Catalog aims to demonstrate the a simple landing page",
"type": "Catalog",
"language": {
"code": "en-US",
"name": "English (United States)"
},
"languages": [
{
"code": "de",
"name": "Deutsch",
"alternate": "German"
}
],
"conformsTo" : [
"https://api.stacspec.org/v1.0.0-rc.2/core",
"https://api.stacspec.org/v1.0.0-rc.2/language"
],
"links": [
{
"rel": "self",
"type": "application/json",
"href": "https://stac-api.example.com",
"hreflang": "en-US"
},
{
"rel": "root",
"type": "application/json",
"href": "https://stac-api.example.com",
"hreflang": "en-US"
},
{
"rel": "service-desc",
"type": "application/vnd.oai.openapi+json;version=3.0",
"href": "https://example.com/api",
"hreflang": "en"
},
{
"rel": "service-doc",
"type": "text/html",
"href": "https://example.com/api.html",
"hreflang": "en-US"
},
{
"rel": "service-doc",
"type": "text/html",
"href": "https://example.com/de/api.html",
"hreflang": "de"
},
{
"rel": "alternate",
"type": "application/json",
"href": "https://example.com/?language=de",
"hreflang": "de"
}
]
}
About
Definitions and recommendations around making multi-lingual STAC APIs available
Resources
Readme
Apache-2.0 license
Activity
Custom properties
Stars
1 star
Watchers
3 watching
Forks
1 fork
Report repository
Releases
Packages
Used by
Contributors