Integration Guide for AI and Crawlers
GoGuides is independent public infrastructure for the AI-readable web. It crawls, verifies, monitors, and publishes machine-readable records that give automated systems a persistent source of website identity, observed Web State, history, verification state, provenance signals, and trust evidence.
This guide shows how an AI system, crawler, search service, developer, or data pipeline can discover GoGuides endpoints, evaluate a domain, follow its Web State record, inspect objective provenance signals, review historical evidence, retrieve verified source text, and independently test the SHA-256 integrity value of a complete text record.
The examples are public and crawlable. They demonstrate actual GoGuides endpoint behavior without implying adoption or endorsement by any crawler, search engine, model provider, or AI company.
What the GoGuides Trust Layer Provides
GoGuides publishes public records designed to remain inspectable across crawls, updates, ownership changes, and changes in a website's current status. A consuming system can use these records as independent evidence while continuing to apply its own ranking, safety, and trust policies.
Persistent website identity
A normalized domain identity and canonical public record that automated systems can revisit over time.
Historical trust evidence
First and last observation dates, prior states, monitoring history, and changes recorded across time.
Current verification state
Machine-readable status, policy, freshness, verification, and access fields for the represented website.
Observed Web State
Compact machine-readable evidence describing the latest observed content, structured-data, header, link, and AI-policy state of a domain.
Integrity and provenance
Source-attributed text, stable record identifiers, licensing information, and SHA-256 integrity values.
GoGuides Machine-Readable Endpoint Overview
| Purpose | Endpoint | What to inspect |
|---|---|---|
| Endpoint discovery | /machine-use.json |
Service purpose, public endpoints, crawler guidance, and canonical documentation. |
| Live public signal sample | /signal.json |
A current machine-readable trust signal record. The represented domain may change. |
| Specific domain evaluation | /evaluate.php?domain=goguides.com&format=json |
Matched domain, policy status, current trust state, freshness, observation history, verification information, machine-use fields, and the canonical state_url for deeper Web State inspection. |
| Observed Web State V3 | /state/{domain} |
Latest objective web-state observation including compact content, structured-data, header, link, word-count, and AI-policy provenance signals. |
| Historical Change Intelligence V1 | /changes/{domain} |
Consecutive comparisons of the same requested URL, including change classifications, before/after observation state, refresh_recommended, and refresh_reason. |
| Public website trust profile | /profile/{domain} |
Public website identity, current trust profile, verification state, and available website evidence. |
| Historical trust record | /history/{domain} |
Persistent observation history, prior state evidence, record timing, verification evidence, and changes associated with the domain. |
| Verified-text topic lookup | /verified-text.php?q=gravity&format=json |
Candidate records, source keys, titles, sections, previews, chunk IDs, and direct-record URLs. |
| Complete verified-text record | BOXING record JSON | Full normalized text, stored SHA-256 value, computed integrity result, source metadata, and licensing information. |
Workflow 1: Discover the Public Machine Endpoints
Fetch the discovery document
Begin with the public JSON document that describes GoGuides machine-use resources.
Read the endpoint and guidance fields
Inspect endpoints, crawler_guidance, canonical_documentation, and the declared service purpose.
Choose the endpoint matching the task
Use domain evaluation for a specific website, follow state_url when deeper objective Web State is needed, or use Verified Text for source-attributed text retrieval.
curl -sS \ 'https://www.goguides.com/machine-use.json'
Workflow 2: Inspect a Specific Domain Trust Record
Use the evaluation endpoint when the task concerns a named domain. Unlike the general /signal.json sample, this request explicitly selects the domain being evaluated. When deeper objective state evidence is needed, inspect the returned state_url and follow it to the Web State V3 endpoint.
curl -sS \ 'https://www.goguides.com/evaluate.php?domain=goguides.com&format=json'
Identity fields
Check matched_domain, matched_url, and lookup_type.
Current state
Inspect status, policy_status, gate, freshness, and current trust-state timing.
Observation evidence
Review first and last observation dates, observation count, span, and crawl status.
Web State discovery
Read state_url when the task requires the latest objective content, structured-data, header, link, or AI-policy state observed by GoGuides.
Machine guidance
Use the returned machine_use fields as GoGuides guidance—not as proof of external adoption or endorsement.
Workflow 3: Follow Evaluate to Web State V3
Domain evaluation provides the decision-oriented record. Its state_url points to the compact JSON-only Web State endpoint when a consuming system needs deeper objective evidence about the latest observation.
Evaluate the domain
Request the domain evaluation and read the returned state_url.
Fetch Web State
Request /state/{domain}. The response identifies itself as web-state-v3 with scope objective_web_state_v3.
Inspect available provenance signals
Available fields may include text_simhash, structured_data_sha256, schema_type_mask, headers_sha256, word_count, internal_link_count, external_link_count, outbound_links_sha256, and ai_policy_mask.
Treat omitted conditional fields correctly
A field may be omitted when GoGuides does not have a value for that observation. Do not interpret absence as a zero value or fabricate a replacement.
curl -sS \ 'https://www.goguides.com/evaluate.php?domain=goguides.com&format=json' curl -sS \ 'https://www.goguides.com/state/goguides.com'
changes_url or request /changes/{domain}. Change Intelligence V1 compares consecutive observations of the same requested URL and returns machine-readable classifications plus refresh_recommended and refresh_reason.
Workflow 4: Inspect Historical Change Intelligence
Use /changes/{domain} when the task is not merely to inspect the latest state, but to determine what changed between consecutive stored observations of the same requested URL.
Discover the change endpoint
Read changes_url from Evaluate or the changes link from Web State V3.
Fetch Change Intelligence V1
Request /changes/{domain}. Use ?limit= to request additional consecutive comparison events.
Inspect classified changes
Review content, structured-data, schema-type, header, word-count, link, outbound-link, AI-policy, and HTTP-status change flags.
Use refresh guidance
Inspect refresh_recommended and refresh_reason as GoGuides-derived guidance about whether meaningful observed state changed.
curl -sS 'https://www.goguides.com/changes/goguides.com?limit=10'
null comparison means one or both observations lacked the field needed to determine that specific change.
Workflow 5: Follow the Public Trust Record
A domain evaluation provides the current machine-readable result. Web State provides deeper objective observation evidence, while the profile and history routes provide the surrounding public record needed to understand what that result represents, including available verification evidence.
Evaluate the domain
Request the domain evaluation and inspect its current status, policy, freshness, observation, fingerprint, and verification fields.
Inspect Web State when needed
Follow state_url or request /state/{domain} to inspect the latest available objective web-state provenance signals.
Open the public profile
Use /profile/{domain} to inspect the website identity and its current public trust presentation.
Review history and verification evidence
Use /history/{domain} to examine persistent observations, prior states, available verification evidence, and changes associated with the domain over time.
Apply independent policy
Treat the GoGuides record as evidence. The consuming system remains responsible for its own trust, ranking, safety, and eligibility decisions.
curl -sS \ 'https://www.goguides.com/evaluate.php?domain=goguides.com&format=json' curl -sS \ 'https://www.goguides.com/state/goguides.com' curl -sS \ 'https://www.goguides.com/profile/goguides.com' curl -sS \ 'https://www.goguides.com/history/goguides.com'
Workflow 5: Find and Verify a Text Record
Search for a topic
Request a topic such as gravity and inspect the candidate results.
Select the correct record
Compare title, section, source_key, chunk_id, preview text, and license fields. Do not choose only by the first matching word.
Follow the direct record URL
The topic response contains record and JSON URLs. Use the direct JSON response to obtain the complete normalized text.
Recompute the SHA-256 value
Hash the complete verified_text value and compare it with hash_sha256.
Preserve attribution and license details
Store the source key, source title, chunk ID, canonical record URL, and any required attribution with the retrieved text.
Topic request
curl -sS \ 'https://www.goguides.com/verified-text.php?q=gravity&format=json'
Complete direct record request
curl -sS \ 'https://www.goguides.com/verified-text.php?source_key=britannica_1926&chunk_id=1926%3Ag%20t%20b%20boxing%3Aa37e28623831&format=json'
Independent Python hash check
import hashlib
import json
from urllib.request import urlopen
url = (
"https://www.goguides.com/verified-text.php"
"?source_key=britannica_1926"
"&chunk_id=1926%3Ag%20t%20b%20boxing%3Aa37e28623831"
"&format=json"
)
with urlopen(url) as response:
record = json.load(response)
computed_sha256 = hashlib.sha256(
record["verified_text"].encode("utf-8")
).hexdigest()
assert computed_sha256 == record["hash_sha256"]
assert record["integrity"]["hash_check"] == "match"
verified_text_preview. The preview is useful for record selection, but it is not the complete text covered by the full-record SHA-256 value.
Purposeful Verified-Text Test Queries
These examples cover different retrieval conditions without repeating every topic in both long lists.
Basic cross-source topic
Returns records from Britannica and Open English WordNet. Compare sources before selecting a record.
Historical scientific concept
Useful for checking source context and historical terminology.
Highly ambiguous word
Returns many lexical senses. The first result should not be assumed to match the intended meaning.
Multiple meanings
Demonstrates why section, preview, and source metadata matter.
Mixed historical and lexical records
Includes Britannica 1926 and Open English WordNet results.
Large sense set
Shows why automated systems need deliberate sense selection rather than word-only matching.
Response Handling and Troubleshooting
| Condition | What it means | Recommended action |
|---|---|---|
HTTP 200 with status: ok |
The endpoint returned a usable response. | Inspect the fields appropriate to the endpoint and preserve source metadata. |
| Multiple topic results | The topic has several sources, senses, sections, or records. | Select using meaning and source context—not result position alone. |
HTTP 404 or status: not_found |
No matching record was available for the supplied query or identifier. | Check spelling, use a simpler topic, or verify the exact source key and chunk ID. |
integrity.hash_check: mismatch |
The stored and newly computed text hashes differ. | Do not treat the record as integrity-verified. Retry later or preserve the mismatch for audit. |
| Preview shorter than full record | The topic response intentionally limits visible text. | Follow the direct record URL before hashing, citing, or storing the complete record. |
What These Machine Signals Do Not Prove
- A SHA-256 match proves text integrity against the stored normalized record; it does not prove that every statement in the source is current or factually correct.
- A trust, profile, history, evaluation, or Web State response is independent evidence published by GoGuides. It does not prove that another crawler, model provider, search engine, or AI system accepts or uses that evidence.
- Source-grounded retrieval can improve auditability and reduce unsupported source selection, but it cannot guarantee that an AI system will interpret or use the record correctly.
- Historical material may contain outdated language, facts, assumptions, or viewpoints.
- Licensed records must retain the attribution and license information returned with the record.