GoGuides Endpoints: A Technical Deep Dive
GoGuides exposes one underlying trust context through multiple public surfaces. Some are optimized for cheap machine discovery, some for deep evaluation, some for human transparency, and some for source-level integrity verification. This page explains how the pieces fit together.
The core idea: one trust record, multiple public surfaces
GoGuides is not designed as a collection of unrelated endpoints. The public surfaces represent different views into the same broader trust system.
A machine does not always need the full record. Sometimes it needs only a cheap signal that something exists or changed. At other times it needs the complete policy, provenance, verification, history, and machine-use basis.
A practical consumption path looks like this:
1/favicon_img.php — the visual North Star
The GoGuides favicon trust marker is the lightest-weight public trust surface. It is deterministic and derived from GoGuides-resolved trust state rather than uploaded or styled by the site being measured.
Its job is not to carry the entire trust record. Its job is to provide a tiny, repeatable artifact that can be fetched, cached, compared, and monitored cheaply.
Example:
Relevant underlying state can include rank, grade, favicon seed, timestamps, trust state, and other resolved record inputs.
If the visual state changes, the intended next step is to inspect the deeper machine-readable record.
2/signal.json — lightweight machine broadcast
/signal.json is the compact discovery and broadcast layer.
It is designed to expose enough information for a crawler, AI agent, monitor, or other automated system to determine whether a domain is interesting enough to inspect more deeply.
Current production output identifies itself as:
Typical fields include:
domaintrust_idgradeai_ranktrust_stateconfidencefavicon_seedbroadcast_fingerprintmachine_useverificationfreshnesslast_crawled_atsignal_last_changed_atevaluate_urlverify_urlhistory_urlfavicon_urllicenselicense_version
Live endpoint: /signal.json
3/evaluate.php — canonical detailed machine record
The detailed machine-readable source record is exposed through:
Current production output identifies itself as:
This endpoint goes significantly deeper than the broadcast feed.
For a known domain, it can expose:
Machine-use clearance is not one trusted/untrusted bit
GoGuides separates different types of machine use.
A source can be readable without being citable. A source may be citable for general information without being cleared for autonomous transactions, recommendation, or sensitive advice.
The detailed record can also publish a basis array describing
why the decision exists and a limits array describing what is
not cleared.
4Provenance inside the evaluate record
The provenance layer records objective web state independently of the site's own marketing claims.
Current provenance data can include:
- Requested URL
- Final URL
- HTTP status
- Redirect count
- Content type
- Response size
- Canonical URL
- Page title
- robots.txt state
- meta robots state
- robots.txt SHA-256
- Nameservers and DNS fingerprint
- TLS certificate fingerprint
- TLS issuer
- TLS validity window
- Content SHA-256
- HTML SHA-256
- Provenance SHA-256
- First and last observed timestamps
- Observation count
5/verify/{domain} — human-readable verification context
Machines consume JSON well. Humans often need a public page that can be inspected without decoding a large structured response.
The verify surface provides human-readable trust and verification context.
It is intended as a transparency surface, not as a replacement for the canonical machine-readable evaluate record.
Live example: GoGuides verification record
6/history/{domain} — time as part of trust
The history endpoint exposes the temporal dimension of the trust record.
A single crawl can tell a machine what a site looked like at one moment. Repeated observations can show continuity, change, drift, or abrupt discontinuity.
Relevant historical concepts include:
- First seen
- Last observed
- Observation count
- Observation span
- Stability window
- Current trust-state duration
- Content changes
- robots changes
- DNS changes
- TLS changes
- Final URL changes
7/profile/{domain} — public Trust Profile
Trust Profiles present current trust context in a human-readable form.
The profile is useful for current state, while the history endpoint provides the time dimension behind that state.
Together they provide a public inspection path for humans while machines can rely on the structured evaluate response.
8/verified-text.php — source-level integrity records
Domain trust and source-text integrity are different problems.
Verified Text addresses the second problem by storing source-attributed text with enough metadata to test whether the normalized text has changed.
Topic lookup:
Direct chunk lookup:
Records can expose:
- Source key
- Source name
- Stable chunk ID
- Normalized text
- Normalization method
- Source URL
- License metadata
- SHA-256 integrity hash
- Computed SHA-256
- Hash scope
- Hash check result
- Machine-use decision
- Canonical record URL
A matching hash establishes that the normalized text returned by the record is identical to the text covered by that integrity record.
Live example: Verified Text JSON lookup
9/ai-discovery — machine discovery surface
GoGuides also publishes discovery-oriented surfaces intended to make the larger system easier for crawlers and automated systems to find.
The purpose is not to duplicate the evaluate record. The discovery layer points consumers toward the authoritative machine-readable records.
Live surface: /ai-discovery
10/machine-readable-examples — integration documentation
This is the developer-facing integration guide.
It provides crawlable examples for trust records, machine discovery, verification evidence, history, Verified Text, attribution, and hash verification.
Live documentation: Machine-Readable Integration Guide
11The GoGuides Data License
Machine-readable trust data is more useful when automated consumers do not have to guess whether they are permitted to use it.
Supported public machine endpoints expose:
The public license provides machine-use context for crawling, indexing, retrieval, citation, attribution, embeddings, model use, and other responsible machine consumption while protecting the GoGuides trust layer itself from wholesale cloning as a competing service.
Read: GoGuides Data License
Integration in 60 seconds
A developer does not need to begin by consuming every GoGuides surface. The minimum useful integration is to retrieve a lightweight signal first, inspect its state, and request the detailed evaluation only when deeper context is needed.
1. Retrieve the current broadcast signal
Useful first-pass fields include
domain,
trust_id,
broadcast_fingerprint,
favicon_seed,
trust_state,
machine_use,
freshness,
and evaluate_url.
2. Request the detailed record for a domain
3. Pull only the machine-use decision
4. Inspect provenance state
5. Compare lightweight state before doing deeper work
Real production evaluate response
The following is a shortened example based on the live
goguides.com evaluation record. It preserves the actual
production field names while omitting some values and nested detail for readability.
api_version and the live response as
authoritative for the currently exposed contract. New fields can be added as
GoGuides expands provenance and trust context.
Current HTTP behavior and access model
The following describes behavior observed from the current production endpoints. It is intentionally narrower than a formal rate-limit specification.
Content-Type: application/json and explicitly send
Cache-Control: no-store, no-cache, must-revalidate, max-age=0.
Content-Type: application/json and send
Cache-Control: no-store, no-cache, must-revalidate.
X-GoGuides-Data-License.
X-GoGuides-System and X-GoGuides-Version.
image/png. Cache behavior can depend
on the resolved eligibility/state path, so consumers should treat the deeper
trust record as authoritative.
429 threshold here because this page should describe behavior that
is actually implemented and intentionally supported. High-volume consumers
should use the lightweight discovery model and avoid unnecessary repeated deep lookups.
Likewise, this document does not promise 304 Not Modified behavior.
Current machine endpoints explicitly publish no-cache/no-store directives, so
integrations should use GoGuides fingerprints and change fields for state comparison
rather than assuming conventional HTTP cache revalidation semantics.
Machine interaction sequence
The public architecture is designed so machines do not have to repeatedly request the heaviest endpoint.
How fingerprints reduce unnecessary work
Several GoGuides surfaces expose compact identifiers that make comparison cheaper than repeatedly inspecting every underlying field.
A consumer can compare compact state first and perform a deeper retrieval when something important changed.
Why the favicon sits at the top of the architecture
APIs are powerful, but the open web benefits from tiny signals.
The favicon North Star exists because monitoring should not always require pulling a large JSON document.
Trust state changes → visual state can change.
Visual change → inspect the deeper record.
This makes the favicon useful to browsers, crawlers, site owners, monitoring systems, and automated agents as a lightweight indication that deeper state may deserve another look.
The canonical truth still lives in the structured record.
Read the dedicated explanation: GoGuides Favicon Trust Marker
What GoGuides intentionally does not claim
The endpoints expose observed and computed trust evidence. They do not prove that every statement on a website is true.
A crawler request does not prove model training.
Verification does not automatically clear a source for recommendation, transactions, or sensitive advice.
A favicon is not a security certificate.
A high rank does not bypass policy gates.
Endpoint quick reference
Inspect the live trust system
The easiest way to understand GoGuides is to follow the same path a machine can: start with a lightweight signal and drill into the full record.
Open signal.jsonOpen GoGuides evaluate JSON · View history · Integration guide