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, change history, verification state, provenance signals, and trust evidence. Machines can also explicitly request GoGuides intelligence for a public URL; when the URL is unknown and passes safety checks, GoGuides may accept it for asynchronous discovery through the normal crawler pipeline.
This guide shows how an AI system, crawler, search service, developer, or data pipeline can discover GoGuides endpoints, explicitly request intelligence for a URL, evaluate a domain, follow its Web State and Change Intelligence records, 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.
On-demand URL intelligence
Automated systems can explicitly request GoGuides intelligence for a full public HTTP or HTTPS URL. Known URLs return stored intelligence; unknown safe URLs may be accepted for asynchronous crawl-on-miss discovery.
How to Interpret GoGuides Evidence
GoGuides publishes both observed or normalized web evidence and GoGuides-derived assessments. These are different categories of information and should not be treated as interchangeable.
Observed and normalized evidence
Examples include crawl timestamps, HTTP observations, content fingerprints and hashes, structured-data observations, header fingerprints, word counts, link counts, and other recorded web-state signals. These describe what GoGuides observed or deterministically normalized from an observation.
GoGuides-derived assessments
Fields such as ai_rank, grade, trust state, policy conclusions, and refresh guidance are GoGuides assessments derived from collected evidence and GoGuides methodology. They are not universal facts or mandatory conclusions for another system.
Consumer control
A consuming system may inspect the underlying observations, use only selected fields, apply different weights, reject a GoGuides assessment, or ignore derived scores entirely. GoGuides does not require a consumer to adopt AI Rank, grade, or trust-state conclusions as ground truth.
Commercial separation
Payment does not buy a higher AI Rank or grade. Commercial monitoring, activation, refresh, dashboard, or service features should not be interpreted as evidence that a website is more trustworthy. Any service-level difference is distinct from the meaning of a GoGuides trust assessment.
Authorization for side effects
This documentation describes available capabilities; it does not itself authorize an autonomous agent to create side effects. Eligible machine Evaluate requests can generate crawl demand: an unknown exact-URL evaluation can asynchronously schedule both the authoritative domain root and requested exact page. POST /request-url remains the explicit attributed acquisition and status workflow. Side-effect-capable use should be permitted by the client's operator, application, integration, or tool policy.
Authority, certification, and independent review
GoGuides does not claim that AI Rank, grade, trust state, or other derived assessments are a government rating, external standard, standards-body certification, or universal authority. GoGuides has not published an independent third-party audit of its derived scoring methodology. Consumers should therefore treat derived assessments as GoGuides conclusions and may independently inspect the underlying observations and apply their own methodology.
GoGuides Machine-Readable Endpoint Overview
| Purpose | Endpoint | What to inspect |
|---|---|---|
| Endpoint discovery | /machine-use.json |
Service purpose, public endpoints, crawler guidance, URL-request capability discovery, and canonical documentation. |
| Machine-readable API contract | /docs/openapi.yaml |
OpenAPI 3.1 contract describing the public machine interfaces, request and response schemas, methods, and status behavior. |
| Request intelligence for a URL | POST /request-url |
Explicit machine request for a full public URL. Known usable intelligence can return immediately; an unknown safe URL may be accepted for asynchronous crawl-on-miss discovery. |
| URL-request status | GET /request-url/status/{request_id} |
Follow an accepted request through its public lifecycle without exposing crawler queue internals. |
| Live public signal sample | /signal.json |
A current machine-readable trust signal record. The represented domain may change. |
| Exact URL evaluation | /evaluate.php?url={absolute_url}&format=json |
Exact stored page observation and that page's own AI Rank, with compact root/domain context. When stored declaration evidence is available, independent_comparison exposes deterministic declaration classification, score derivation, source alignment, comparison eligibility, and explicit abstention. Eligible machine misses schedule both the authoritative domain root and the requested exact page; ordinary non-machine reads do not create crawl work. |
| 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} |
Deterministic comparisons of concrete stored observations for the authoritative domain root. change-v1 returns exact observation IDs/timestamps, field-level flags, simhash Hamming distance, numeric deltas, and explicit changed/unchanged/unknown/insufficient-history/observation-gap states without assigning a subjective rewrite severity. |
| 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 Evaluate with domain= for the authoritative root/domain record, or with url= for one exact page. A known exact page returns that page's own AI Rank and public observation with compact domain context. When an eligible machine exact-URL evaluation finds no stored page observation, GoGuides treats the lookup as crawl demand and asynchronously schedules both the authoritative domain root and the requested exact URL. POST /request-url remains the explicit attributed acquisition and status workflow. Follow state_url and changes_url for deeper domain-level stored evidence, or use Verified Text for source-attributed text retrieval.
curl -sS \ 'https://www.goguides.com/machine-use.json'
Independent Comparison for Exact URLs
Exact-URL Evaluate may include an
independent_comparison object with capability
goguides.independent_comparison and API version
comparison-v1.
The current deterministic classifier is
publisher-declaration-v2. It separates the factual
observation that a publisher made a claim from the separate
question of whether that claim can responsibly be compared with
GoGuides' independently derived exact-page assessment.
Declaration state
Possible states are
no_declaration,
publisher_defined,
ambiguous_namespace_trust_claim,
comparable_declaration,
stale_or_temporally_uncertain, and
unclassified.
Direct comparison is narrow
A direct numeric comparison requires one explicit GoGuides
AI Rank claim containing an integer from 0
through 100, an independently computed
exact-page score, exact requested-URL scope, and proven
snapshot alignment.
Publisher numbers remain publisher claims
A publisher-defined numeric value is not compared with AI Rank merely because both are numbers. Generic trust-shaped metadata remains ambiguous when its authority is unclear.
Snapshot alignment
source_alignment uses exact URL, AI Rank,
HTTP status, title SHA-256, and extracted-text SHA-256
evidence. Timestamp proximity alone is not proof of
snapshot identity.
Score derivation
Inspect
score_scope,
score_derivation,
source_scope, and
comparison_eligible.
Abstention is intentional
When evidence does not justify a comparison,
abstained: true is a valid result.
Consumers should preserve the returned
reason_code rather than inventing a conclusion.
{
"independent_comparison": {
"capability_id": "goguides.independent_comparison",
"api_version": "comparison-v1",
"classification_method": "deterministic_ruleset",
"classification_version": "publisher-declaration-v2",
"declaration_state": "ambiguous_namespace_trust_claim",
"directly_comparable": false,
"observation": {
"score_scope": "exact_page",
"score_derivation": "independently_page_computed",
"source_scope": "stored_exact_requested_url_observation",
"comparison_eligible": false
},
"source_alignment": {
"method": "exact_url_rank_status_title_text_hash_v1",
"aligned": true,
"reason_code": "CRYPTOGRAPHIC_SNAPSHOT_MATCH"
},
"comparison": null,
"abstained": true
}
}
Workflow 2: Batch Evaluate Multiple Exact URLs
GET + POST /evaluate-batch exposes capability
goguides.evaluate_batch using API version
evaluate-batch-v1. Both transports call one internal
service and reuse normal exact-URL Evaluate authority.
GET for bounded machine clients
Repeat url= once per ordered input. GET accepts
up to 10 URLs and a 7000-byte request target.
POST for larger structured batches
Send {"urls":[...]} as
application/json. POST accepts up to 50 URLs.
Map results by index
Input order is preserved and each item contains an explicit
zero-based index. Safe results survive individual
item validation failures.
Keep Evaluate demand separate from adoption
Eligible machine misses may generate asynchronous Evaluate
crawl demand subject to root policy and queue budgets.
Batch activity never counts as explicit
POST /request-url adoption.
GET example
curl -sS --get \ --data-urlencode 'url=https://www.goguides.com/data-license' \ --data-urlencode 'url=https://www.iana.org/help/example-domains' \ 'https://www.goguides.com/evaluate-batch'
POST example
curl -sS \
-H 'Content-Type: application/json' \
--data '{"urls":["https://www.goguides.com/data-license","https://www.iana.org/help/example-domains"]}' \
'https://www.goguides.com/evaluate-batch'
V1 applies bounded public request, input, and response limits. Clients that reach a public limit receive a structured error or retry guidance. Operational queue, cooldown, and emergency-control details remain internal.
Focused documentation:
/docs/evaluate-batch.html.
Claim Support V1 — source-grounded model-assisted judgment
POST /claim-support analyzes one claim against one fixed
current GoGuides stored source observation. The capability is
goguides.claim_support and the API version is
claim-support-v1.
Verdicts are supported, contradicted,
unaddressed, insufficient_evidence, and
source_unavailable. This is model-assisted analysis,
not a certificate of truth, not cryptographic verification, and not
a replacement for independent review.
curl -sS \
--request POST \
--header 'Content-Type: application/json' \
--data '{"url":"https://www.goguides.com/data-license","claim":"GoGuides publishes a data license."}' \
'https://www.goguides.com/claim-support'
Claim Support uses stored GoGuides evidence and does not synchronously
fetch the target website. It does not create explicit
POST /request-url adoption. Unknown or unavailable sources
abstain and can be followed through Evaluate or Request URL as a separate
caller-controlled workflow.
Responses use Cache-Control: no-store. V1 exposes no public
numeric model confidence and does not publish private model, prompt,
threshold, queue, or abuse-control internals.
Claim Support Feedback V1 — bounded governance feedback
POST /claim-support/feedback records structured feedback
about one existing Claim Support analysis_id. The capability
is goguides.claim_support_feedback and the API version is
claim-support-feedback-v1.
curl -sS \
--request POST \
--header 'Content-Type: application/json' \
--data '{"analysis_id":"gca_...","reason_code":"evidence_mismatch"}' \
'https://www.goguides.com/claim-support/feedback'
Accepted reason codes are verdict_disputed,
evidence_mismatch, source_mismatch,
source_stale, insufficient_context, and
analysis_other_issue. Repeated equivalent feedback may be
deduplicated.
Feedback is a review signal, not a vote on truth. Submission does not automatically change the original verdict, source observation, or analysis lifecycle state.
Claim Support Status V1 — durable analysis lifecycle
GET /claim-support/status/{analysis_id} reports the current
lifecycle state of one previously issued Claim Support analysis. The
capability is goguides.claim_support_status and the API
version is claim-support-status-v1.
States are active, flagged,
superseded, and withdrawn. A superseded record
can point to a public replacement analysis. A withdrawn record can expose
a safe reason category.
Status polling is observational only. It does not crawl the source, create a URL Request, trigger re-analysis, or rewrite the historical verdict. Persisted verdicts are versioned analysis results rather than permanently current truth, so consumers should re-check lifecycle status according to their own risk and freshness needs.
Workflow 2: Request GoGuides Intelligence for a URL
For a client whose operator, application, integration, or tool policy has explicitly authorized this capability, POST /request-url provides GoGuides intelligence for a full public HTTP or HTTPS URL. This is the explicit URL-request surface for crawl-on-miss behavior, with request attribution and status tracking. Domain/root Evaluate can act as a demand signal: eligible machine lookups may asynchronously schedule domain discovery or contribute to throttled hot-recrawl freshness for a known record. For an eligible machine exact-URL lookup that misses stored page intelligence, GoGuides asynchronously schedules both the authoritative domain root and the requested exact URL. Ordinary non-machine exact-URL reads do not create crawl work. POST /request-url remains the explicit attributed acquisition and status workflow. State and Changes return stored observations; freshness maintenance is asynchronous.
machine-use.json, or the OpenAPI contract is not permission for an autonomous system to create a side effect. An eligible machine exact-URL Evaluate miss can schedule both root and exact-page crawl work. POST /request-url remains the explicit attributed acquisition and status workflow. Side-effect-capable use should be permitted by the client's operator or governing tool policy.
Submit the full public URL
Send JSON containing url and freshness: use-current-or-crawl-on-miss. Do not use a GET request for this action endpoint.
Handle known intelligence immediately
If GoGuides already has usable stored intelligence for the exact URL, the endpoint can return HTTP 200 with status: available. The returned links.evaluate follows that exact URL's page record; links.domain_evaluate separately exposes the authoritative root/domain record.
Handle crawl-on-miss asynchronously
If the URL is unknown, public, and passes request safety and capacity controls, GoGuides can return HTTP 202 Accepted with status: crawl_accepted, a high-entropy request ID, a status URL, and retry guidance. The request handler does not synchronously fetch the target URL.
Poll the public status URL
Use GET /request-url/status/{request_id}. The public status can progress through the request lifecycle and eventually expose completion or failure without revealing internal queue details.
Follow the canonical GoGuides result
When complete, follow the canonical Evaluate, State, Changes, and History links. The crawler-created observation becomes the canonical GoGuides stored record for that result; the URL request itself records request intent and does not let the caller write or dictate a trust assessment.
Request example
curl -sS \
--request POST \
--header 'Content-Type: application/json' \
--header 'Accept: application/json' \
--data '{"url":"https://example.com/article","freshness":"use-current-or-crawl-on-miss"}' \
'https://www.goguides.com/request-url'
POST /request-url.
Full contract and examples: URL Request API documentation · OpenAPI specification
Workflow 3: 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 4: 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}. Capability goguides.change_intelligence / API change-v1 compares concrete stored observations of the authoritative domain root and exposes mechanical field changes and magnitudes without inferring publisher intent.
Workflow 5: 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 change_state, the exact previous_observation/current_observation IDs and timestamps, text_simhash_hamming_distance, numeric count deltas, and deterministic equality/difference flags. Treat observation_gap as an explicit chronology limitation rather than guessing. V1 does not label a change as a major rewrite or infer why the publisher changed it.
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 6: 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 one evidence source. The consuming system may independently evaluate the underlying observations, disregard GoGuides-derived scores, and 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 7: 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 |
|---|---|---|
URL Request: HTTP 200 with status: available |
GoGuides already has usable stored intelligence for the requested URL. | Follow the returned canonical result links. No crawl-on-miss work is required for that request. |
URL Request: HTTP 202 with status: crawl_accepted |
The unknown safe URL was accepted for asynchronous crawler discovery. | Preserve the request ID and poll the returned status URL according to the retry guidance. |
URL Request: HTTP 405 method_not_allowed |
The action endpoint was requested with the wrong HTTP method, such as GET. | Use POST /request-url with a JSON request body. Use the documentation URL for ordinary browser navigation. |
| URL Request: rejected or failed | The request failed validation, safety, policy, capacity, verification, or crawler processing. | Inspect the public reason/status fields. Do not infer or attempt to reconstruct internal crawler queue state. |
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, Web State, Change Intelligence, or URL Request response is evidence published by GoGuides. It does not prove that another crawler, model provider, search engine, or AI system accepts or uses that evidence downstream.
- AI Rank, grade, trust state, policy conclusions, and refresh guidance are GoGuides-derived assessments. They are not universal ground truth and do not require another system to reach the same conclusion.
- Publishing integration instructions does not authorize an autonomous client to create side effects. An eligible machine exact-URL Evaluate miss can schedule root and exact-page crawl work, while
POST /request-urlprovides explicit attributed acquisition and status tracking. Side-effect-capable use must be permitted by the client's operator, application, integration, or tool policy. - A verified Web Bot Auth signature proves cryptographic control of the signing identity used for that request. It does not by itself prove endorsement, benign intent, model training, citation, recommendation, dependency, or commercial intent.
- 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.