goguides.com trust favicon wikipedia.org trust favicon mozilla.org trust favicon
GoGuides Trust Layer Active — public records, crawler transparency, and machine-readable trust signals.
Log In Navigation
Public endpoints URL Request API Web Bot Auth Web State V3 JSON examples SHA-256 verification

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.

GoGuides provides independent public evidence. Each consuming system remains responsible for deciding how much weight to give that evidence.

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.

A consumer can use GoGuides as an additional evidence source without accepting GoGuides-derived scores as the final decision. The consumer remains responsible for its own ranking, trust, safety, eligibility, citation, and source-selection policies.

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
  }
}
Important: this object reports evidence and GoGuides' deterministic comparison decision. It does not certify a publisher claim as universally true and does not require another system to adopt the GoGuides conclusion.

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.

One mouth, one truth path: Batch Evaluate does not calculate a second AI Rank and does not create a second policy decision. The same normalized exact URL is resolved through the same authoritative evaluator used by normal exact-URL Evaluate. Root/domain context remains a separate root 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.

Authorization boundary: discovering this documentation, 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'
Web Bot Auth: GoGuides supports RFC 9421 HTTP Message Signatures for capable automated clients. A successfully verified signature can establish cryptographic request attribution. Web Bot Auth is optional on the current public path, and verification does not prove endorsement, downstream citation, training use, commercial intent, or benign behavior.
Reads of State, Changes, Signal, History, and Verified Text remain observational and do not trigger URL-request crawl-on-miss behavior. Evaluate is different: eligible machine domain/root evaluation may generate discovery or freshness demand, and an eligible machine exact-URL miss schedules both the authoritative domain root and the requested exact URL. Evaluate-generated crawl demand does not count as URL-request adoption. URL-request adoption requires an explicit external 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'
Web State V3 reports the latest available observation. For historical comparison, follow 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'
Change Intelligence V1 is derived from stored GoGuides observations. Freshness maintenance is asynchronous, and a 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"
Topic results may contain a shortened 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

Gravity JSON lookup

Returns records from Britannica and Open English WordNet. Compare sources before selecting a record.

Historical scientific concept

Ether JSON lookup

Useful for checking source context and historical terminology.

Highly ambiguous word

Bank JSON lookup

Returns many lexical senses. The first result should not be assumed to match the intended meaning.

Multiple meanings

Current JSON lookup

Demonstrates why section, preview, and source metadata matter.

Mixed historical and lexical records

Matter JSON lookup

Includes Britannica 1926 and Open English WordNet results.

Large sense set

Light JSON lookup

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