An agency receives two JSON exports for the same AI monitoring period. The files have different checksums. One is indented for reading, while the other is compact and lists object fields in another order. Before announcing that an answer changed, compare the records under an agreed data model.
The reverse problem matters too. Two records can look almost identical while differing in a source array, an identifier's type or a field that disappeared. A useful export review identifies which differences affect the buyer's intended analysis and preserves the original files for inspection.
This guide develops five fictional comparison cases. They concern representation and data interpretation. The files represent invented editorial records, with no authenticated consumer capture or vendor-account export.
Keep the received bytes and parsed record identifiable
A file checksum supports a comparison of the exact bytes supplied to the algorithm. NIST's Secure Hash Standard describes the role of message digests in detecting changes. Preserve each received export and its digest before making a derived representation for comparison. NIST Secure Hash Standard
A JSON parser reads those bytes into a representation of their structured values. The review can then compare fields and values under the chosen schema. Give that comparison its own method and output so another reviewer can distinguish it from a byte-for-byte check.
For a monitoring report, retain the export time and scope as well. An observation's collection time, a review-label update and the creation of a new export can describe different events. The comparison should identify which object changed.
Understand which order belongs to the JSON value
RFC 8259 describes objects as collections of named values and arrays as ordered sequences. It also permits insignificant whitespace around structural characters. Those definitions help explain why file formatting and the order of object members can change without changing the intended field mapping. RFC 8259 JSON specification
An export contract should identify the schema and any additional field semantics. A source array might preserve the order displayed in an answer. Another field might be defined as an unordered collection by the application's schema. Keep that declared meaning with the comparison rule.
For the examples below, the record has an answer identifier, text, a mention count and a source-identifier array. The count is a small integer. The identifiers are strings. The source array preserves its stated order. Those choices define this fictional fixture.
Freeze the export boundary before comparing formats
A format selector leaves several questions for the buyer. Which prompts and dates contributed records? Which fields were selected? How does the file associate an answer with its source links? Keep those settings with the received file before comparing its values.
OtterlyAI's prompt-detail guide describes response downloads in CSV or JSON at the individual-prompt level. It also distinguishes the response preview from the detailed view containing full text and available citation links. For a procurement test, select an authorized prompt, record the displayed scope and inspect the actual fields in each downloaded format. OtterlyAI prompt-detail documentation
Promptwatch documents a filtered response-table export with selectable columns, Excel and CSV formats, a 10,000-response cap and Professional-or-higher plan eligibility. Its listed columns include Response, All Citation URLs and Self Cited URLs. Record the actual column selection and applicable limit with each file. If a column is absent from the second export, check the saved selection before treating that absence as changed source data. Promptwatch response-export documentation
The two documented workflows give this review a practical starting point. Request a field dictionary for the purchased route. Match an authorized answer identifier, the full text and the available source relationships against the corresponding screen. Then inspect how strings, missing values and nested collections survive each delivery format. The five cases below supply local comparison exercises for that inspection.
Source labels need a field-level definition too. Promptwatch's source guide describes inline citations, end-of-answer footnotes and search-result links, while allowing a flat list for records without that classification. Preserve a supplied group label in the comparison. For a flat URL collection, describe the retained association at that level and ask how a sentence-level relationship can be inspected. Promptwatch source classifications
These are current vendor-documented examples reviewed on November 15, 2026. A buyer still needs the actual file and account scope for its intended analysis. The comparison method should identify its input fields, retained records and transformations so a later reviewer can reproduce the result.
Compare five fictional cases
All names, records and results in this table are invented. Each case changes a declared property of the fixture so the reviewer can follow the comparison.
| Case | Change between two supplied representations | Result under this exercise's rule |
|---|---|---|
| A | Whitespace and object-member order change | Different bytes, same parsed field mapping |
| B | Two source identifiers reverse order in an array | Parsed array differs |
| C | A note field is absent, null or an empty string | Three distinct record states |
| D | An object repeats the answer-identifier field | Rejected by the exercise's duplicate-field rule |
| E | An accented character uses two Unicode encodings | Distinct strings until the declared normalization comparison |
For case A, compare a compact record with a pretty-printed version containing the same named values. Recalculate both raw-file digests. Then parse both using the exercise's duplicate-rejecting reader and compare their resulting records.
The local example produces different raw bytes and equal parsed mappings. A deterministic serialization defined for this restricted fixture produces the same derived bytes for both. Its scope is deliberately small and does not claim a complete implementation of a general canonicalization scheme.
Preserve array order when the schema gives it meaning
Case B keeps the same two source identifiers but reverses their sequence. Under the fixture's ordered-source rule, that is a data change. An object-field sort should leave that sequence intact.
A buyer may later decide to compare citation membership separately from citation order. Define those as separate derived comparisons. If a repeated source identifier is allowed, a set conversion would also discard its multiplicity. Decide whether that information matters before selecting the operation.
For a real AI answer, the source record may carry several meanings, including display order, destination and association with a passage. The actual schema and capture method determine which meanings the export preserves. A comparison should report the fields available to it and retain unresolved associations.
The result can state that the two exported source arrays differ in order under a named schema. Establishing why the supplier produced that difference requires the underlying records and workflow.
Give missing, null and empty fields their own meanings
Case C compares a record without a note field, a record whose note has a null value and a record whose note is an empty string. A consumer should preserve those distinct structures before applying any contract-specific interpretation.
For example, the buyer might define an absent field as unavailable in that export version and an empty string as an explicitly empty note. That would be a documented application rule. The JSON format alone leaves the business meaning to the data contract.
This matters when a pipeline replaces every missing source field with an empty list. The resulting record can lose the distinction between unavailable source extraction and a completed observation that exposed no sources. Specify the actual collection and export states before calculating a citation rate.
Keep schema versions with the records. A field added in a later export may leave earlier records structurally different without proving that their original answers changed.
Reject ambiguous duplicate fields under the agreed rule
Case D repeats the answer-identifier field with two different strings. RFC 8259 recommends unique object-member names and discusses inconsistent behavior when they are duplicated. Our fictional acceptance rule rejects such a record before comparison. RFC 8259 object guidance
Record that rejection with the original file and a specific error. A convenient parser that keeps only the final occurrence would hide information needed to understand the received record. The buyer should know how the selected import route handles the case.
Use a small authorized fixture to test the actual pipeline. Include the duplicate field in a local test file and inspect the importer result through the normal route. A rejected record, an excluded record and a silently altered record belong to different outcomes in the acceptance log.
The rule is a requirement of this proposed procurement exercise. Apply the real system's documented data contract when evaluating an actual delivery.
Make Unicode normalization an explicit transformation
Case E uses an accented letter represented once as a precomposed character and once as a base character followed by a combining mark. Unicode's normalization annex explains canonical equivalence and normalization forms. A chosen normalization can bring the two fixture strings to a common representation. Unicode normalization guidance
The received strings still need their own retained originals. Record the normalization form and the fields to which the operation applies. An answer-text comparison, a display-name match and an observation-identifier comparison can have different requirements.
For the fixture, the two strings differ before normalization and agree after applying NFC. That establishes the stated local text relationship. It supplies no general rule for merging visually similar company names, identifiers or citation destinations.
A buyer should also decide how to handle changes in line endings and escaped characters. Compare parsed string values when that is the declared task, and preserve the raw file when byte identity matters.
Ask which canonicalization scheme is actually offered
RFC 8785 describes the JSON Canonicalization Scheme, or JCS. It defines deterministic property sorting and primitive serialization, with input restrictions. It preserves Unicode string data and leaves Unicode normalization as a separate transformation. The document is an Informational RFC. RFC 8785 JCS
If a supplier offers JCS, request the implementation and conformance evidence relevant to the purchased workflow. Confirm how it handles duplicate fields, numbers, character sequences and arrays. A function that sorts ordinary object keys can illustrate one restricted fixture while leaving the complete scheme unresolved.
Specify the canonicalization version and the object covered by a digest or signature. A file containing a report wrapper, export timestamp and answer records has a different scope from one canonicalized individual answer. A later export timestamp can change the package even if every answer remains unchanged.
Keep the original export, any canonicalized output and the transformation description linked. A reviewer can then reproduce the comparison at the intended level.
Protect identifiers and numerical values during import
An identifier written as a string should remain a string through the agreed route. Leading characters and zeroes can carry meaning in an identifier. Converting it into a number introduces another interpretation that needs an explicit schema rule.
For numeric measurements or counts, establish the accepted range, precision and rounding. A receiving system's number handling can affect what survives a parse-and-serialize cycle. Use representative boundary values when that risk matters to the report.
The local fixture uses small integer counts and string identifiers to keep its comparison scope clear. It does not exercise every numeric representation, Unicode boundary or malformed input. Broader interoperability acceptance needs additional cases selected for the actual data contract.
Use the comparison in an AI visibility handover
Agree the schema, field meanings and comparison rules before receiving a reporting export. Preserve the original response files, then produce a record-level difference report that identifies changed fields and the method used.
For one authorized observation, trace the identifier, complete text and available citation relationships through the delivery. If two exports disagree, determine whether the change concerns formatting, record content, later classification or report membership. Keep the capture evidence for any claim about what the consumer platform originally returned.
Semvi by Xindar's product reference describes product-owner-confirmed complete-answer and citation-URL export. The actual account, delivered schema and comparison behavior need their corresponding acceptance. Product scope and buyer verification, Semvi introduction
Questions about comparing exports
Can different checksums describe the same parsed record?
Yes. Case A changes formatting and member order while preserving the fixture's field mapping. Retain both the byte-level finding and the defined record comparison.
Should source arrays always be sorted?
Follow their declared schema meaning. The fixture preserves source order. A separately defined membership comparison can coexist with that ordered record.
Why reject duplicate object fields?
The exercise uses a duplicate-rejecting rule to avoid an ambiguous received mapping. The actual importer and contract should state their behavior and preserve a useful error record.
Does JCS normalize accented characters?
JCS preserves Unicode string data. A Unicode normalization comparison is another transformation with its own defined scope and retained original.
What proves the original AI platform returned the text?
Inspect the actual capture record and collection context. File parsing, normalization and checksum comparisons establish their particular data relationships within the handover.
Sources and method
The linked specifications and public product reference were reviewed on November 14, 2026. The named vendor export examples were checked against their official documentation on November 15, 2026. The five cases use fictional local records. The checks cover their declared serialization, parsing, duplicate-field and Unicode relationships. A full JCS implementation, actual vendor export and authenticated platform capture remain separate acceptance tasks.
