Your timing stack delivers time. GAL-2 adds a governed application layer: the GAL-2 API creates GAL-2 Time, the GAL-2 Node makes it locally consumable, and the Time Contract governs when it is safe to use.
Keep your timing stack. Install the GAL-2 Node. Connect the application once.
Developer quickstart
Start by testing your GAL-2 API access directly against the production endpoint. You can also explore GAL-2 through RapidAPI. For the resilient local application path, install GAL-2 Node, connect it to active GAL-2 API access, and consume GAL-2 Time locally through the Time Contract, SHM, or SDK Provider.
Direct API test · RapidAPI · GAL-2 Node v1.0.0-rc10 · Linux ARM64 · Local Time Contract · SHM · SDK Provider
Live GAL-2 API test
Paste your GAL-2 API key below to call the production GAL-2 API directly
and inspect the live response from
https://api-v2.gal-2.com/time.
Your key is used only for this browser request and is not stored by this page.
This tester calls the GAL-2 API only. It does not test GAL-2 Node, SHM, the SDK Provider, HOLDOVER, or the local Time Contract.
{
"status": "waiting",
"message": "Paste a GAL-2 API key and click Test API."
}If the browser blocks the request because of CORS or browser/network policy, use the curl fallback below.
curl -s \
-H "x-api-key: YOUR_GAL2_API_KEY" \
-H "Accept: application/json" \
https://api-v2.gal-2.com/time | python3 -m json.toolUse the live tester above for a direct request to the production GAL-2 API. You can also use RapidAPI for API exploration, development, experiments, and workloads that do not require Node-managed local continuity.
Install GAL-2 Node beside the application and provide active GAL-2 API access. The Node then makes GAL-2 Time locally consumable and exposes the Time Contract, bounded continuity, controlled recovery, SHM, and SDK Provider path.
Current Node release
GAL-2 Node v1.0.0-rc10 is the current signed limited release for Linux ARM64. Install the Node beside your application, configure active GAL-2 API access, and consume GAL-2 Time locally.
An active paid GAL-2 API plan is required for normal LIVE operation. The Node maintains upstream GAL-2 synchronization while application reads occur locally through the Time Contract, SHM, or SDK Provider. Local application reads do not each consume a separate upstream API request.
080a17dc6f477a6a707e78efe14412d3a0f15d38cc2829cda0ddd9bf8024ac6b
Direct API request
Use your GAL-2 API key to call the production endpoint directly. This is the same endpoint used by the live tester above.
export GAL2_API_KEY="YOUR_GAL2_API_KEY"
curl -s \
-H "x-api-key: $GAL2_API_KEY" \
-H "Accept: application/json" \
https://api-v2.gal-2.com/time | python3 -m json.toolNever place an API key in public source code, screenshots, logs, repositories, or support messages.
RapidAPI request
RapidAPI provides an additional API exploration and subscription path. Use the endpoint, host, and API-key header shown by RapidAPI for your account.
curl -s \
-H "x-rapidapi-key: YOUR_RAPIDAPI_KEY" \
-H "x-rapidapi-host: gal-2-tm-time-api1.p.rapidapi.com" \
"https://gal-2-tm-time-api1.p.rapidapi.com/time"If RapidAPI displays a different host or base URL for your account, use the values provided by RapidAPI.
Example API response
A direct API call returns GAL-2 Time and API-visible metadata. The exact API response schema may evolve independently of the local Time Contract schema, so applications should follow the documented interface for the access path they use.
{
"gal2_time": "2026-05-27T17:34:38.399767Z",
"utc_time": "2026-05-27T17:34:38.404894Z",
"drift": {
"base_ms": -7.83,
"wobble_ms": 4.134,
"live_ms": -5.127
},
"fractal_factor": 3.761473,
"source": "fractal+secret(hmac)+ema"
}This example preserves an observed API response shape from the GAL-2 API lineage. The metadata describes API behavior. It does not disclose the protected Fractal Time formula and is not a metrological UTC-certification claim.
Direct API examples
fetch(
"https://api-v2.gal-2.com/time",
{
headers: {
"x-api-key": "YOUR_GAL2_API_KEY",
"Accept": "application/json"
}
}
)
.then((response) => response.json())
.then(console.log);import requests
headers = {
"x-api-key": "YOUR_GAL2_API_KEY",
"Accept": "application/json",
}
response = requests.get(
"https://api-v2.gal-2.com/time",
headers=headers,
timeout=10,
)
print(response.json())Full resilient product path
Direct API access is supported when Node-managed local continuity is not required. For an application that needs the resilient local GAL-2 path, install the Node and connect the application once.
The application then consumes GAL-2 locally through the Node. The Node maintains bounded continuity, controlled recovery, fail-closed behavior, and local publication without silently substituting raw host time.
# Inspect local Time Contract state
curl -s http://127.0.0.1:9095/contract | python3 -m json.tool
safe_to_consume
is authoritative for the enrolled GAL-2 path.
Node API usage
Suitable for API development, testing, and intermittent Node use. Not intended for one Node running continuously 24/7 at the standard polling interval.
100,000 monthly requests supports one continuously running GAL-2 Node at the standard 30-second polling interval.
Approximately 86,400 upstream requests in a 30-day month or 89,280 in a 31-day month.
Application reads from the local Node do not each consume an upstream API request. The Node maintains the upstream GAL-2 synchronization path.
Historical evaluator lineage
Before the current GAL-2 Node release, RC5.8 provided a public Time Contract evaluator surface for macOS and Linux Docker ARM64. Those artifacts remain useful for release-history, packaging, IXOYE witness, and Time Contract evidence.
They are not the current GAL-2 Node release. Current product downloads should use GAL-2 Node v1.0.0-rc10.
/witness surface, and evaluator results should be
interpreted according to the exact RC5.8 artifact.
They are not being retroactively relabeled as RC10 testing.