
Api Batch Response
Batch API response mixing success and failure per sub-request.
- File
- JSON · Api
- Use case
- API testingJSON parsing
Data files are where parsers quietly break, so this category leans into the edge cases. The CSV set runs from clean to deliberately messy — quoted commas, embedded newlines, ragged rows, semicolon and tab delimiters, a headerless file, a ten-thousand-row file, and a Latin-1 encoded file. JSON comes flat, deeply nested, as JSON Lines, and intentionally invalid for error-handling tests. OpenAPI and JSON Schema twins, paginated API and webhook fixtures, and irregular time-series edges cover modern API QA. There's XML, YAML, and a real SQLite database with related tables, plus faker-generated user and order datasets with documented schemas. Each file spells out its exact quirks in the spec, so when your importer chokes you know precisely which case did it.
Filter data on Browse · 430 files · 49 subcategories

Batch API response mixing success and failure per sub-request.

Cursor-paginated SAMPLE API response page 1 with nextCursor metadata.

Cursor-paginated SAMPLE API response page 2 with nextCursor metadata.

Empty paginated response — edge case for UI empty states and merge logic.

A 404 error body in RFC 9457 (problem+json) form, with type, title, status, detail, and instance — for testing structured error handling and problem-detail parsers.

A 422 validation-error response with a machine-readable list of field errors — for testing form-validation surfacing and error mapping.

RFC 5988 Link header pagination metadata as JSON for HTTP client tests.

Nested pagination object for comments under a post — tests deeply nested page tokens.

Offset/limit paginated SAMPLE response page 1 for list-merge tests.

Offset/limit paginated SAMPLE response page 2 for list-merge tests.

RFC 7807 SAMPLE problem document for HTTP 400 (Bad Request) client tests.

RFC 7807 SAMPLE problem document for HTTP 409 (Conflict) client tests.

RFC 7807 SAMPLE problem document for HTTP 403 (Forbidden) client tests.

RFC 7807 SAMPLE problem document for HTTP 410 (Gone) client tests.

RFC 7807 SAMPLE problem document for HTTP 500 (Internal Server Error) client tests.

RFC 7807 SAMPLE problem document for HTTP 406 (Not Acceptable) client tests.

RFC 7807 SAMPLE problem document for HTTP 404 (Not Found) client tests.

RFC 7807 SAMPLE problem document for HTTP 503 (Service Unavailable) client tests.

RFC 7807 SAMPLE problem document for HTTP 429 (Too Many Requests) client tests.

RFC 7807 SAMPLE problem document for HTTP 401 (Unauthorized) client tests.

RFC 7807 SAMPLE problem document for HTTP 422 (Unprocessable Entity) client tests.

RFC 7807 SAMPLE problem document for HTTP 415 (Unsupported Media Type) client tests.

Rate-limit header values captured as JSON for middleware testing.

Page 1 of a paginated JSON API response (users), with page metadata and a `hasMore` flag. Paired with page 2 for testing pagination and infinite-scroll logic.

Page 2 (the final page) of a paginated JSON API response. Paired with page 1 for testing pagination, `hasMore` handling, and list merging.

Paginated response where total count disagrees with items length — tests inconsistency detection.

GraphQL error response with message and location — negative case for GraphQL clients.

Partial GraphQL introspection result for schema-stitching tests.

Sample GraphQL mutation success payload for testing mutation handlers.

Sample GraphQL query response with nested user and orders — for GraphQL client tests.

A GraphQL Schema Definition Language (SDL) file with queries, a mutation, object/input types, and an enum — for testing GraphQL schema parsers, linters, and code generators.

GraphQL subscription event payload for realtime client tests.

A small but complete OpenAPI 3.1 description (two paths, three schemas) in JSON — for testing API tooling, mock servers, client codegen, and docs generators.

The same OpenAPI 3.1 description in YAML — the format most API definitions ship in. Paired with the JSON twin for testing YAML↔JSON conversion and spec parsers.

Callback payload matching the Wave F webhook OpenAPI SAMPLE.

A proto3 Protocol Buffers schema with messages, an enum, and a repeated field — for testing protobuf compilers (protoc), codegen, and schema tooling.

Documented HMAC webhook signature SAMPLE — no real secret, for verifier unit tests.

SAMPLE github push webhook JSON body for signature-verification and parser tests.

SAMPLE slack message webhook JSON body for signature-verification and parser tests.

SAMPLE stripe payment webhook JSON body for signature-verification and parser tests.

A bank-transaction statement — 60 debits and credits across three accounts (masked numbers) with running balances, categories, and merchants. Synthetic data for testing statement parsers, categorisation, and reconciliation.

The bank transactions as a JSON array — the format twin of the CSV, for import and reconciliation testing.

A sample ISO 20022 customer credit-transfer initiation (pain.001.001.09) — a single payment with debtor/creditor parties, IBANs, BICs, amount, and remittance info. IBANs are published documentation examples; a fixture for testing payment-message parsers and bank integrations.

A reference list of well-known payment TEST card numbers (Visa, Mastercard, Amex, Discover, JCB, Diners) with sample CVV and expiry. These are published test values that pass the Luhn check but are not real accounts — for testing payment forms and card validators. Never use real card data.

The same records as Apache Avro — a compact row-based binary format that embeds its own schema, widely used in Kafka pipelines. For testing Avro decoders and schema evolution.

The records as BSON — the binary-JSON encoding MongoDB stores documents in. For testing BSON decoders and JSON↔BSON conversion.

The records as CBOR — the IETF concise binary object representation used in IoT and COSE/WebAuthn. For testing CBOR decoders and JSON↔CBOR conversion.

The employee table as a dBase (DBF) file — the venerable xBase table format still emitted by GIS tools and legacy databases. For testing DBF readers and DBF→CSV conversion.

The same table as Feather (Arrow IPC file) — the zero-copy on-disk form of an Apache Arrow table. For testing Arrow readers and fast columnar interchange.

A small HDF5 file with a compound 'employees' dataset and a numeric 'readings' grid — the hierarchical format used across science and ML. For testing h5py/HDF5 readers and conversion.

The records as MessagePack — a compact binary serialization that maps onto the JSON data model, common in caches and RPC. For testing MessagePack codecs and JSON↔MessagePack conversion.

The same employee table as Apache ORC — the columnar format common in the Hive/Hadoop ecosystem. For testing ORC readers and Parquet↔ORC conversion.

A small employee table as Apache Parquet — the columnar format at the heart of modern data lakes and analytics. For testing Parquet readers (pandas, Spark, DuckDB) and conversion.

A single protobuf User message in binary wire format (varint + length-delimited fields) — the serialized counterpart to the user.proto schema. For testing protobuf decoders without the generated code.

An intentionally corrupt iCalendar file whose VEVENT is never closed, for testing fatal component-nesting errors without using a large or hostile payload.

A complete iCalendar structure using LF-only line endings, a common recoverable export defect for tolerant parser tests.

A standards-conforming event with a folded content line and UTF-8 text for baseline parser and line-unfolding tests.

A recurrence set with both an exclusion and an explicit addition, useful for catching expansion engines that apply only one modifier.

A weekly five-occurrence series that provides the recurrence baseline before exclusions or additions are applied.

The same weekly series with its third occurrence excluded, for testing RRULE expansion followed by EXDATE filtering.

The terminal cancellation for the scheduling group, checking METHOD, STATUS, UID and sequence precedence together.

An attendee acceptance for the same meeting, used to test UID correlation and PARTSTAT state updates.

The invitation that starts a scheduling lifecycle, using stable UID and organizer/attendee identities.

The UTC representation of the Toronto event, providing an exact normalization target for calendar importers.

A floating-time variant with no TZID or Z suffix, for verifying that parsers do not silently reinterpret local wall time as UTC.

A TZID-qualified event immediately after Toronto's spring-forward boundary, with an explicit VTIMEZONE definition.

A fictional contact carrying the same tiny portrait in the version-specific photo syntax used by vCard 2.1, 3.0 and 4.0. This member uses vCard 2.1 syntax.

A fictional contact carrying the same tiny portrait in the version-specific photo syntax used by vCard 2.1, 3.0 and 4.0. This member uses vCard 3.0 syntax.

A fictional contact carrying the same tiny portrait in the version-specific photo syntax used by vCard 2.1, 3.0 and 4.0. This member uses vCard 4.0 syntax.

An iCalendar (.ics) file with a single event and CRLF line endings per spec — for testing calendar imports.

A fictional contact with repeated typed properties for testing importers that otherwise keep only the first value. This member uses vCard 2.1 syntax.

A fictional contact with repeated typed properties for testing importers that otherwise keep only the first value. This member uses vCard 3.0 syntax.

A fictional contact with repeated typed properties for testing importers that otherwise keep only the first value. This member uses vCard 4.0 syntax.

A fictional business contact with structured organization and postal-address fields for CRM migration tests. This member uses vCard 2.1 syntax.

A fictional business contact with structured organization and postal-address fields for CRM migration tests. This member uses vCard 3.0 syntax.

A fictional business contact with structured organization and postal-address fields for CRM migration tests. This member uses vCard 4.0 syntax.

A fictional multilingual contact for checking Unicode decoding and round trips between legacy and current vCard versions. This member uses vCard 2.1 syntax.

A fictional multilingual contact for checking Unicode decoding and round trips between legacy and current vCard versions. This member uses vCard 3.0 syntax.

A fictional multilingual contact for checking Unicode decoding and round trips between legacy and current vCard versions. This member uses vCard 4.0 syntax.

A vCard 3.0 contact with name, email, phone, and address — for testing contact importers.

JSON description of nullable columns in the null-heavy columnar fixtures.

Feather file with dictionary-encoded strings — Arrow IPC edge-case fixture.

Feather/Arrow IPC twin of the null-heavy table — grouped with the Parquet nulls fixture.

Amounts stored as strings in Parquet — common ingestion edge case for ETL parsers.

Parquet with dictionary-encoded string column — tests dictionary page decoding.

Parquet with repeated key values — tests join/aggregation edge cases.

Empty Parquet file with schema but no rows — edge case for readers.

Parquet with a list-of-string column — tests repeated-field decoding.

Parquet with bool/int/string/float columns including a null integer.

Parquet with a struct column — tests nested type round-trips.

Tiny Parquet table with null name/score/note cells — tests null handling in columnar readers.

Single-row Parquet table — minimal columnar fixture.

Tiny Apache rewrite rules SAMPLE for .htaccess parser tests.

Sample INI config file for legacy config parser tests.

Sample TOML application config for TOML parser tests.

JSON application settings for config-merge and validation tests.

AWS credentials file shape with obviously fake keys — for credential scanner and parser tests.

Minimal CI pipeline YAML for GitHub Actions / GitLab CI parser tests.

Tiny SAMPLE JSON config fixture (app-feature-flags) for parser and twin tests.

Tiny SAMPLE TOML config fixture (app-feature-flags) for parser and twin tests.

Tiny SAMPLE YAML config fixture (app-feature-flags) for parser and twin tests.

Tiny SAMPLE JSON config fixture (cors-origins) for parser and twin tests.

Tiny SAMPLE ENV config fixture (database-pool) for parser and twin tests.

Tiny SAMPLE INI config fixture (database-pool) for parser and twin tests.

Tiny SAMPLE YAML config fixture (k8s-resource-snippet) for parser and twin tests.

Tiny SAMPLE INI config fixture (logging-levels) for parser and twin tests.

Tiny SAMPLE YAML config fixture (rate-limit) for parser and twin tests.

Tiny SAMPLE TOML config fixture (redis-cache) for parser and twin tests.

Tiny SAMPLE YAML config fixture (redis-cache) for parser and twin tests.

Tiny SAMPLE ENV config fixture (smtp-relay) for parser and twin tests.

A sample docker-compose file defining a web service with Postgres and Redis dependencies — for testing Compose parsers and YAML tooling.

Sample docker-compose override file for merge/extends parser tests.

A sample multi-stage Dockerfile with a build stage and a slim runtime stage — for testing Dockerfile parsers, linters (hadolint), and syntax highlighting. Illustrative only.

SAMPLE .env file (comments-edge) for dotenv parser and config-loader tests — placeholders only.

SAMPLE .env file (development) for dotenv parser and config-loader tests — placeholders only.

SAMPLE .env file (production-template) for dotenv parser and config-loader tests — placeholders only.

SAMPLE .env file (testing) for dotenv parser and config-loader tests — placeholders only.

A sample environment (.env) file with typical configuration keys and placeholder values — for testing dotenv parsers and config loaders. Contains no real secrets.

A classic INI configuration file with sections and key/value pairs — for testing INI parsers.

SAMPLE Kubernetes configmap manifest — fictional names, no real cluster secrets.

SAMPLE Kubernetes deployment manifest — fictional names, no real cluster secrets.

SAMPLE Kubernetes ingress manifest — fictional names, no real cluster secrets.

SAMPLE Kubernetes secret manifest — fictional names, no real cluster secrets.

SAMPLE Kubernetes service manifest — fictional names, no real cluster secrets.

Minimal nginx reverse-proxy config SAMPLE for syntax highlighter and linter tests.

Sample terraform.tfvars with fictional region — for HCL/tfvars parser tests.

A TOML configuration file with tables, inline values, and an array of tables — for testing TOML parsers.

A W3C Web App Manifest (JSON) with name, theme colours, and icon set — for testing PWA install prompts and manifest validators.

A CSV with 10,000 data rows — for testing streaming parsers, memory handling, and import performance.

A clean, well-formed CSV with a header and 20 rows — the baseline case for CSV parser testing.

Tiny SAMPLE CSV (empty-fields) exercising delimiter/quoting edge behaviour.

Tiny SAMPLE CSV (hash-commented) exercising delimiter/quoting edge behaviour.

Tiny SAMPLE CSV (header-only) exercising delimiter/quoting edge behaviour.

Tiny SAMPLE CSV (mixed-quoting) exercising delimiter/quoting edge behaviour.

Tiny SAMPLE CSV (pipe-delimited) exercising delimiter/quoting edge behaviour.

Tiny SAMPLE CSV (quoted-embedded-comma) exercising delimiter/quoting edge behaviour.

Tiny SAMPLE CSV (quoted-embedded-newline) exercising delimiter/quoting edge behaviour.

Tiny SAMPLE CSV (semicolon-eu) exercising delimiter/quoting edge behaviour.

Tiny SAMPLE CSV (single-column) exercising delimiter/quoting edge behaviour.

Tiny SAMPLE CSV (trailing-comma) exercising delimiter/quoting edge behaviour.

A CSV with no header row — for testing parsers that must infer or be told the column names.

A CSV encoded in Latin-1 (ISO-8859-1) with accented names — for testing encoding detection and mis-decoding (it will look wrong if read as UTF-8).

A deliberately messy CSV: a quoted field with a comma, a quoted field with an embedded newline, escaped double-quotes, and ragged rows with too few and too many fields — the cases that break naïve parsers.

A CSV that uses semicolons as the delimiter (common in European locales) — for testing delimiter detection.

A tab-separated values file with a header and 20 rows — for testing TSV parsing and delimiter handling.

A real SQLite database with two related tables — users and orders joined by a foreign key — for testing database importers and SQL tooling.

A draw.io (diagrams.net) diagram in its native mxGraphModel XML — a small flowchart — for testing draw.io import/export and XML parsing of diagram files.

A Graphviz DOT directed graph describing a fulfilment pipeline — for testing DOT parsing, Graphviz rendering, and DOT-to-SVG/PNG conversion.

A Mermaid flowchart of an order-fulfilment process as diagrams-as-code — for testing Mermaid rendering, diagram-to-image conversion, and Markdown pipelines that embed Mermaid.

A PlantUML sequence diagram of an order interaction (customer, store, warehouse) as diagrams-as-code — for testing PlantUML parsing and diagram rendering pipelines.

A realistic e-commerce customer directory (500 rows) — part of a relational dataset (products, customers, orders) with CSV, JSON, SQL, and Parquet twins for testing joins, imports, and conversion.

The e-commerce customers table as a JSON array — the format twin of the CSV, for import and conversion testing.

A relational SQL schema (products, customers, orders with primary and foreign keys) plus sample INSERTs — the DDL twin of the e-commerce dataset, for testing schema import and migrations.

A realistic e-commerce order lines (customer_id → customers, product_id → products) (2000 rows) — part of a relational dataset (products, customers, orders) with CSV, JSON, SQL, and Parquet twins for testing joins, imports, and conversion.

The e-commerce orders table as a JSON array — the format twin of the CSV, for import and conversion testing.

The e-commerce orders table as Apache Parquet — the columnar twin, for testing analytics engines (pandas, DuckDB, Spark).

A realistic e-commerce product catalogue (200 rows) — part of a relational dataset (products, customers, orders) with CSV, JSON, SQL, and Parquet twins for testing joins, imports, and conversion.

The e-commerce products table as a JSON array — the format twin of the CSV, for import and conversion testing.

The e-commerce products table as Apache Parquet — the columnar twin, for testing analytics engines (pandas, DuckDB, Spark).

Timestamps spanning a US spring-forward DST gap and leap-day dates for timezone and calendar edge-case testing.

A sanitization-test CSV with one equals-prefixed cell clearly labelled sample-only. Use it to verify importers neutralize spreadsheet formulas — not an attack list.

A small CSV whose header row repeats the column name id — a common importer failure mode.

SKU identifiers that start with zeros. Spreadsheet tools often coerce these to numbers and drop the zeros — keep them as text.

A CSV where missing values are written seven different ways — empty string, NULL, NA, N/A, null, None, and a dash — across text and numeric columns. A fixture for testing null-detection and coercion in CSV importers.

A CSV listing timestamps in eleven formats — ISO 8601 with Z and numeric offsets, millisecond precision, naive local, date-only, Unix epoch in seconds and milliseconds, US AM/PM, and RFC 1123. A fixture for testing date parsing and timezone normalisation.

A CSV whose 'value' column mixes integers, floats, scientific notation, dates, hex, thousands separators, and whitespace, and whose 'flag' column mixes a dozen boolean spellings. A torture test for type inference and schema detection.

A JSON object that repeats several member names (name, tags, timeout, active). RFC 8259 permits duplicate keys but leaves the result parser-defined — most keep the last. A fixture for testing how a JSON parser resolves duplicates.

A CSV with 1000 columns and a handful of rows — a stress test for parsers, spreadsheet importers, and databases with column limits or per-row buffering assumptions. Deterministic (fixed seed).

A CSV with # comment lines mixed among data — common in scientific exports; tests comment skipping.

A Latin-1 CSV with high-bit accented characters — for legacy 8-bit charset detection.

A CSV that mixes CRLF and LF row endings within one file — newline normalisation fixture.

A pipe-delimited (| ) tabular file — for testing non-comma delimiter autodetection.

A CSV with a quoted field that contains an embedded newline — a classic RFC 4180 parser stress case.

Rows with differing field counts — for testing how importers pad, truncate, or error on ragged CSV.

European-style CSV using semicolons as delimiters and comma decimals — a common locale edge case.

A Shift-JIS encoded Japanese CSV — for CJK charset detection and Shift-JIS→UTF-8 conversion in importers.

A one-column CSV of email addresses — edge case for delimiter sniffers that expect commas in every row.

UTF-16 big-endian CSV with BOM — for byte-order detection in tabular importers.

The same three data rows as UTF-16 little-endian with a BOM — wide-character CSV decoding fixture.

A CSV prefixed with a UTF-8 BOM (EF BB BF) and accented / CJK cells — for testing BOM-aware importers.

A CP1252 CSV using the 0x80–0x9F range (smart quotes, euro, bullet) that Latin-1 misreads.

A .csv file whose content is tab-delimited — tests whether importers sniff delimiters or trust the extension.

A classic fixed-width text extract with documented column positions — for COBOL-style / mainframe importer tests.

A 1000-row orders dataset whose user_id references the users dataset — a relational fixture for testing joins and import flows. Paired with a JSON twin.

The 1000-row orders dataset as JSON — the format twin of the CSV version, relational to the users dataset.

A 500-row dataset of fake but realistic users (name, email, address, date of birth), generated with a fixed seed. Paired with a JSON twin.

The 500-row users dataset as a JSON array — the format twin of the CSV version, for testing import and conversion.

A well-formed Atom feed with multiple entries — for testing feed readers and parsers.

An HTTP Live Streaming (HLS) media playlist in UTF-8 M3U8 — #EXT-X-VERSION, target duration, four timed .ts segments, and #EXT-X-ENDLIST — for testing HLS parsers and adaptive-streaming players.

A JSON Feed 1.1 document — the JSON alternative to RSS/Atom — with a feed header and three items using content_html, content_text, tags, and publish dates, for testing JSON Feed parsers and readers.

An extended M3U media playlist with #EXTINF duration and title directives over three track references (local and remote) — for testing playlist parsers and media players.

An OPML 2.0 subscription list with nested outline groups and three feed entries (title, xmlUrl, htmlUrl) — the format RSS readers use to import and export subscriptions, for testing OPML parsers.

A well-formed RSS 2.0 feed with a channel and multiple items — for testing feed readers and parsers.

Synthetic finance dataset (ledger-lines) as CSV — for ETL and warehouse loader tests.

JSON twin of the finance/ledger-lines mini-dataset.

A year of daily OHLCV stock candles (open/high/low/close/volume) as a seeded random walk — a realistic finance time-series for testing charting, indicators, and importers. JSON twin included.

The daily OHLCV candles as a JSON array — the format twin of the CSV, for charting and time-series testing.

End-of-month account balance snapshot for open-banking API mock tests.

Synthetic bank statement line items for reconciliation tooling tests.

Balanced double-entry ledger SAMPLE for accounting engine validation tests.

Daily USD/EUR SAMPLE rates for FX chart and conversion tests.

Stripe-style payment intent SAMPLE JSON for checkout integration tests.

Synthetic suspicious-activity flag JSON for AML compliance workflow tests.

Synthetic bank transaction history for personal-finance importer tests.

A GeoJSON FeatureCollection with a point, a line, and a polygon — for testing map tools and geo importers.

A GPX track with timestamped trackpoints and elevation — for testing route parsers and mapping tools.

A KML document with named placemarks — for testing Google Earth / mapping importers.

The same 40 world cities as a GeoJSON FeatureCollection of Points (longitude, latitude order per RFC 7946), each with name, country, and population properties. The mapping twin of the CSV, for testing GeoJSON parsers and map renderers.

A curated world-cities dataset — 40 major cities with country, latitude, longitude, and population. A realistic geospatial fixture for testing map plots, geocoding, and CSV→GeoJSON conversion. GeoJSON twin included.

A six-stage software pipeline DAG for testing dependency import, cycle checks and reproducible topological sorting. This GEXF 1.3 member carries the same node IDs, edge IDs, directions and weights as its two format twins.

A six-stage software pipeline DAG for testing dependency import, cycle checks and reproducible topological sorting. This GraphML member carries the same node IDs, edge IDs, directions and weights as its two format twins.

A six-stage software pipeline DAG for testing dependency import, cycle checks and reproducible topological sorting. This JSON edge list member carries the same node IDs, edge IDs, directions and weights as its two format twins.

A four-service directed cycle whose only valid topological result is failure, for dependency-analysis regression tests. This GEXF 1.3 member carries the same node IDs, edge IDs, directions and weights as its two format twins.

A four-service directed cycle whose only valid topological result is failure, for dependency-analysis regression tests. This GraphML member carries the same node IDs, edge IDs, directions and weights as its two format twins.

A four-service directed cycle whose only valid topological result is failure, for dependency-analysis regression tests. This JSON edge list member carries the same node IDs, edge IDs, directions and weights as its two format twins.

A directed graph with two linked islands and one isolated node, designed for weak-component and isolated-node tests. This GEXF 1.3 member carries the same node IDs, edge IDs, directions and weights as its two format twins.

A directed graph with two linked islands and one isolated node, designed for weak-component and isolated-node tests. This GraphML member carries the same node IDs, edge IDs, directions and weights as its two format twins.

A directed graph with two linked islands and one isolated node, designed for weak-component and isolated-node tests. This JSON edge list member carries the same node IDs, edge IDs, directions and weights as its two format twins.

A directed service-dependency graph in GraphML — ten microservices (web, api, auth, db, cache, queue, worker, …) with their call/dependency edges. A fixture for testing directed-graph importers, cycle detection, and topological sorting.

The same 12-person social network in GEXF 1.3 (Gephi's native format) — node attributes and weighted edges. The format twin of the GraphML file, for testing Gephi imports and GraphML↔GEXF conversion.

A small synthetic social network in GraphML — 12 people in two communities with a few bridging ties, carrying node attributes (name, age, community) and weighted edges. Twinned with a GEXF file for testing graph importers and format converters.

A weighted acyclic multigraph with two parallel source-to-router edges, checking multiplicity and floating-point weight preservation. This GEXF 1.3 member carries the same node IDs, edge IDs, directions and weights as its two format twins.

A weighted acyclic multigraph with two parallel source-to-router edges, checking multiplicity and floating-point weight preservation. This GraphML member carries the same node IDs, edge IDs, directions and weights as its two format twins.

A weighted acyclic multigraph with two parallel source-to-router edges, checking multiplicity and floating-point weight preservation. This JSON edge list member carries the same node IDs, edge IDs, directions and weights as its two format twins.

Sample GraphQL Schema — small deterministic fixture for parsers and the in-browser editor.

A sample HL7 FHIR R4 bundle with a Patient plus vital-sign Observations, an Encounter, and a Condition — a realistic healthcare-interoperability fixture for testing FHIR parsers and mappers. Synthetic data, not a real person.

Synthetic FHIR Claim resource for healthcare billing parser tests — not a real patient.

Fictional insurance eligibility check response for prior-auth workflow tests.

Synthetic lab result rows for clinical data warehouse import tests.

Sample HL7 v2 ORM order message with PID and OBR segments — fictional patient and order ids.

Synthetic patient demographics CSV for EHR import and de-identification pipeline tests.

Synthetic e-prescription JSON for pharmacy routing and validation tests.

SAMPLE procedure code list with fees for medical billing calculator tests.

An employee directory — 30 staff with department, title, hire date, salary, and manager reference. Synthetic HR data for testing org-chart builders, directory imports, and payroll pipelines.

The employee directory as a JSON array — the format twin of the CSV, for HR import testing.

Synthetic hr dataset (employees-mini) as CSV — for ETL and warehouse loader tests.

JSON twin of the hr/employees-mini mini-dataset.

A monthly payroll summary derived from the employee directory — headcount, annual and monthly gross totals, and a per-department breakdown. A fixture for testing finance/HR dashboards and JSON aggregation.

Multi-level bill-of-materials SAMPLE for MRP and assembly planning tests.

Cycle-count variance SAMPLE for inventory audit reconciliation tests.

Synthetic purchase order JSON for procurement workflow tests.

Fictional SKU catalog for ERP and POS import tests.

Per-warehouse stock quantities for inventory reconciliation tests.

Warehouse and bin metadata for WMS routing tests.

Synthetic iot dataset (sensor-readings-mini) as CSV — for ETL and warehouse loader tests.

JSON twin of the iot/sensor-readings-mini mini-dataset.

A day of IoT sensor readings (temperature, humidity, pressure) at one-minute intervals from three sensors, with a realistic daily cycle plus noise — for testing time-series ingestion and downsampling. JSON twin included.

The IoT sensor readings as a JSON array — the format twin of the CSV, for time-series testing.

A deeply nested JSON document with objects inside arrays inside objects — for testing recursive parsing and path access.

A flat JSON array of ten simple objects — the baseline case for JSON parsing and mapping.

An intentionally invalid JSON file with a trailing comma and a missing closing brace — for testing parser error handling and messages. Not valid JSON by design.

A JSON Lines file with one object per line — for testing streaming/newline-delimited JSON parsers.

A draft-07 JSON Schema describing a user object — for testing schema validators and schema-aware tooling.

A newline-delimited JSON (NDJSON) stream of event records — for testing streaming JSON parsers.

Synthetic lab readings (temperature, pressure, pH) with ISO timestamps for scientific ETL tests. CSV twin.

Synthetic lab readings (temperature, pressure, pH) with ISO timestamps for scientific ETL tests. JSON twin.

A 50,000-row transactions dataset — an in-repo 'large' fixture for testing streaming CSV parsers, import performance, and pagination. Deterministic (fixed seed).

An Apache access log in the Combined Log Format — the Common fields plus referer and user-agent. A realistic web-server log for testing access-log parsers, analytics, and grok patterns.

An Apache access log in the Common Log Format (CLF) — client, timestamp, request line, status, and byte count. Deterministic, with reserved documentation IPs. Paired with a Combined-format twin for testing log parsers.

A Docker json-file container log — one JSON object per line with the log text, stream (stdout/stderr), and an RFC 3339 timestamp, exactly as Docker's default logging driver writes it. A fixture for container-log shippers and parsers.

A realistic Java stack trace — a Spring-style NullPointerException with a nested 'Caused by' chain and '... N more' elision. A fixture for testing stack-trace parsers, error groupers, and log viewers.

A structured application log with one JSON object per line at info/debug/warn/error levels — for testing log ingestion.

A Kubernetes-component log in the klog/glog format — a severity letter, timestamp, thread id, and source location prefix followed by the message. A fixture for testing klog parsers and severity extraction.

Tiny SAMPLE log excerpt (app-json-structured) for parser and alert-rule tests.

Tiny SAMPLE log excerpt (cloudflare-ray-sample) for parser and alert-rule tests.

Tiny SAMPLE log excerpt (multiline-stacktrace) for parser and alert-rule tests.

Tiny SAMPLE log excerpt (nginx-access-sample) for parser and alert-rule tests.

Tiny SAMPLE log excerpt (nginx-error-sample) for parser and alert-rule tests.

Tiny SAMPLE log excerpt (systemd-journal-excerpt) for parser and alert-rule tests.

An nginx combined-format access log with several requests, including a 403 and a 404 — for testing log parsers.

A realistic Node.js/Express stack trace — a TypeError with V8-style 'at function (file:line:col)' frames including an async frame and internal node: frames. A fixture for testing JS stack-trace parsers.

A realistic Python traceback with a chained exception ('During handling of the above exception...') and a caret error indicator. A fixture for testing traceback parsers and error-reporting tools.

A structured application log in logfmt — space-separated key=value pairs (ts, level, msg, method, path, status, duration, request_id) as used by many Go and Heroku-style services. A fixture for testing logfmt parsers.

A BSD-style syslog (RFC 3164) sample — timestamp, host, process and PID, then the message, across sshd, cron, kernel, nginx, and application entries. A fixture for testing syslog parsers and forwarders.

Synthetic multi-touch attribution click rows with UTM fields — for marketing analytics importers. CSV twin.

Synthetic multi-touch attribution click rows with UTM fields — for marketing analytics importers. JSON twin.

A valid Jupyter notebook (nbformat 4.5) with markdown cells, code cells, and real outputs (stdout stream and an execute result) — for testing notebook parsers, nbconvert, and JSON tooling.

Binary orc source for the five-row P8 employee conversion table, preserving ids, names, departments, booleans, and scores. Stable P8 artifact p8-convert-orc-source.

Csv semantic reference for the five-row P8 employee conversion table, preserving ids, names, departments, booleans, and scores. Stable P8 artifact p8-convert-orc-csv.

Json semantic reference for the five-row P8 employee conversion table, preserving ids, names, departments, booleans, and scores. Stable P8 artifact p8-convert-orc-json.

Valid Protobuf wire record with string, uint32, and string fields for schema-guided decoding. Stable P8 artifact p8-convert-protobuf-source.

Expected JSON semantic result for the schema-guided Protobuf decode. Stable P8 artifact p8-convert-protobuf-expected.

Valid wire bytes intentionally supplied without a matching schema so tools must preserve unknown field 15. Stable P8 artifact p8-convert-protobuf-missing-schema.

Proto3 schema companion declaring the three fields used by the binary creator record. Stable P8 artifact p8-convert-protobuf-schema.

A point-of-sale SKU catalog with tax codes and active flags — fictional Meridian Supply inventory. CSV twin.

A point-of-sale SKU catalog with tax codes and active flags — fictional Meridian Supply inventory. JSON twin.

Sample Protobuf Schema — small deterministic fixture for parsers and the in-browser editor.

A property-listings dataset — 30 homes with address, type, price, beds/baths, size, year built, coordinates, and status. Synthetic data for testing listing importers, map plots, and price analytics.

The property listings as a JSON array — the format twin of the CSV, for import and mapping tests.

A MovieLens-style ratings log — 240 user/item/rating events with Unix timestamps across 50 users and 40 items. A fixture for testing recommender pipelines, collaborative-filtering loaders, and sparse-matrix builders.

Synthetic product-analytics events (signup/login/upgrade) for testing event pipelines and warehouse loads. CSV twin.

Synthetic product-analytics events (signup/login/upgrade) for testing event pipelines and warehouse loads. JSON twin.

The compatible Avro record schema for reader/writer compatibility tests. Backward compatible for old records: nullable email is added with a null default.

The baseline Avro record schema for reader/writer compatibility tests. Reference writer schema: id and name are strings.

The breaking Avro record schema for reader/writer compatibility tests. Breaking relative to baseline: id changes to long and tenantId has no default.

Draft-07 JSON Schema describing a SAMPLE event object for domain-specific validator tests.

Intentionally invalid JSON Schema (json-schema-bad-ref) for negative validator tests.

Intentionally invalid JSON Schema (json-schema-empty-object) for negative validator tests.

Intentionally invalid JSON Schema (json-schema-missing-type) for negative validator tests.

OpenAPI with a response schema $ref pointing at a missing component — tests broken-reference detection.

OpenAPI document with paths set to null — intentionally invalid for negative schema tests.

OpenAPI with an unsupported openapi version string — negative case for version validators.

Draft-07 JSON Schema describing a SAMPLE inventory item object for domain-specific validator tests.

Draft-07 JSON Schema describing a SAMPLE invoice object for domain-specific validator tests.

JSON Schema allOf merging id and name requirements — tests composite schema validation.

Minimal JSON Schema SAMPLE focusing on additional properties false constraints.

Minimal JSON Schema SAMPLE focusing on array unique items constraints.

Minimal JSON Schema SAMPLE focusing on dependent required constraints.

Minimal JSON Schema SAMPLE focusing on enum currency constraints.

Minimal JSON Schema SAMPLE focusing on format uri email constraints.

Minimal JSON Schema SAMPLE focusing on nullable optional constraints.

Minimal JSON Schema SAMPLE focusing on one of status constraints.

Minimal JSON Schema SAMPLE focusing on pattern sku constraints.

JSON Schema with a oneOf union over string vs number tagged objects — for testing union validation.

The compatible member of a JSON Schema 2020-12 customer contract. Backward compatible: existing instances remain valid because email is optional.

The baseline member of a JSON Schema 2020-12 customer contract. Reference contract: id and name are required strings.

The breaking member of a JSON Schema 2020-12 customer contract. Breaking relative to baseline: id changes from string to integer and tenantId becomes required.

Minimal OpenAPI 3.1 document with a webhooks section — for testing webhook-aware spec parsers.

OpenAPI document with empty paths but populated components — tests partial spec loaders.

Sample POST /pets request body matching the pet-store OpenAPI spec.


Sample 404 problem response for OpenAPI error-handling tests.

Sample paginated pet list response for mock-server and contract tests.

The compatible member of a complete OpenAPI 3.1 ticket endpoint contract. Backward compatible: an optional priority response property is added and existing operations stay unchanged.

The baseline member of a complete OpenAPI 3.1 ticket endpoint contract. Reference API: string ticket IDs and required id/summary response properties.

The breaking member of a complete OpenAPI 3.1 ticket endpoint contract. Breaking relative to baseline: ticket id becomes integer and status becomes a required response property.

Invalid payment JSON (negative amount, short currency) for schema error reporting tests.

Valid payment JSON instance paired with the payment JSON Schema.

Draft-07 JSON Schema for payment amount/currency validation in fintech API tests.

A valid OpenAPI 3.1 pet-store SAMPLE spec in JSON — list/create pets with paginated responses for schema-validator and codegen tests.

YAML twin of the valid pet-store OpenAPI spec — for testing YAML spec parsers and JSON↔YAML conversion.

A product object that deliberately violates the product JSON Schema in five ways (out-of-range id, empty name, non-positive price, wrong boolean type, an extra property) — the negative case for testing validator error reporting.

A product object that conforms to the product JSON Schema — the positive case for testing a JSON-Schema validator.

A JSON Schema (draft-07) describing a product object, with required fields, types, and constraints — paired with a conforming and a deliberately non-conforming instance for testing validators.

The compatible proto3 Customer message for field-number and wire-compatibility testing. Backward compatible: existing field numbers/types are retained and optional email uses new field number 3.

The baseline proto3 Customer message for field-number and wire-compatibility testing. Reference wire contract: field 1 is string id and field 2 is string name.

The breaking proto3 Customer message for field-number and wire-compatibility testing. Breaking relative to baseline: field number 2 is reused with a different name and wire type.

User JSON deliberately violating the schema five ways — negative case for validator error reporting.

JSON instance conforming to the Wave F user JSON Schema — positive validator test case.

Draft 2020-12 JSON Schema for a user object with email format and role enum — paired with valid/invalid instances.

A BibTeX bibliography with three real citations (Lovelace, Knuth, Shannon) across article, book, and inproceedings types — for testing BibTeX parsers, reference managers, and citation converters.

A minimal but valid FITS image — a primary header of 80-character cards padded to a 2880-byte block, followed by a 16x16 unsigned-byte pixel gradient — for testing FITS readers and header-card parsers.

An MDL Molfile (V2000) of a water molecule with standard geometry — a counts line, atom block with 2D coordinates, and bond block — for testing cheminformatics parsers and MOL/SDF converters.

A NetCDF-3 (classic) file holding a small CF-convention gridded temperature field over latitude, longitude, and time, with named dimensions and units — for testing NetCDF readers like netCDF4 and xarray.

The same water molecule in PDB format with fixed-column HETATM coordinate records and a CONECT bond record — for testing molecular-structure parsers and viewers and PDB/MOL conversion.

The same three references as an RIS citation file with two-letter tags and ER record terminators — the twin of the BibTeX file, for testing RIS import and BibTeX/RIS conversion.

A PKCS#10 certificate signing request (PEM) with the subject and SAN, self-signed by the RSA key to prove key possession — for testing CSR parsers and certificate-authority intake flows.

An Ed25519 private key in PKCS#8 PEM, derived from a fixed seed — a published, sample-only modern elliptic-curve key for testing PEM parsers and Ed25519 tooling. Never use it for real.

An Apache/nginx .htpasswd file with two users hashed using the {SHA} scheme (Base64 SHA-1) — the sample passwords are documented in the file, for testing Basic-Auth credential parsers and hash identification.

A PKCS#12 (.p12/PFX) bundle packaging the sample RSA key and certificate together, protected with the sample password 'novus-sample' — for testing keystore importers and PKCS#12 parsers. (The PKCS#12 MAC salt is random, so this file is intentionally not byte-stable.)

A 2048-bit RSA private key in unencrypted PKCS#8 PEM — a deliberately PUBLISHED, sample-only key for testing PEM key parsers and PKCS#8 decoders. Never use it for anything real.

The decoded header and payload of the sample JWT as JSON, alongside the public signing secret and algorithm — the ground truth for checking a JWT decoder's output.

A sample JSON Web Token (JWT) signed with HS256 using a published example secret — verifiable but powerless — for testing JWT decoders and validators. Sample only, never for production. Paired with its decoded claims.

An OpenSSH-format Ed25519 public key (the shareable half of the key pair) — a single line of algorithm, Base64 key blob, and comment, for testing SSH public-key parsers and authorized_keys tooling.

The same self-signed certificate under the conventional .crt extension (PEM-encoded) — for testing trust-store importers and tools that key off the .crt extension. Sample only.

The binary DER encoding of the same certificate — for testing ASN.1/DER parsers, Java keystores, and DER-to-PEM converters. Published sample certificate, not a real identity.

A self-signed X.509 v3 certificate in PEM (Base64) encoding with a SAN and key-usage extensions — published sample material for testing certificate and TLS parsers. Not a real identity.

A football-style league table — position, played, won/drawn/lost, goals for/against, goal difference, and points for ten teams, derived from a full round of synthetic match results. Paired with the results JSON.

The full round of match results behind the league table — home/away teams, scores, and dates as a JSON array. A fixture for testing sports-data importers and standings calculators.

A MySQL-flavour SQL dump with backtick-quoted identifiers and engine options — for testing SQL importers.

A Postgres-flavour SQL dump with a CREATE TABLE and INSERT statements — for testing SQL importers and migrations.

The customer dimension of a star schema — surrogate key, name, city, country, and segment. Joins to the sales fact table on customer_key. Names are synthetic.

The date dimension of a star schema — one row per day with a YYYYMMDD surrogate key and calendar attributes (year, quarter, month, weekday). Joins to the sales fact table on date_key.

The product dimension of a star schema — surrogate key, SKU, name, category, and unit price. Joins to the sales fact table on product_key.

The sales fact table at the centre of a star schema — 300 sale lines with foreign keys to the date, product, and customer dimensions plus quantity and amount measures. A fixture for testing joins, star-schema imports, and BI tools.

Synthetic support dataset (tickets) as CSV — for ETL and warehouse loader tests.

JSON twin of the support/tickets mini-dataset.

A customer-survey response set — 60 respondents rating five statements on a 1–5 Likert scale plus a 0–10 NPS score and a segment. A fixture for testing survey analysis, aggregation, and NPS/CSAT calculations.

Deterministic synthetic CSV batch 01 for bulk-import smoke tests.

Deterministic synthetic JSON batch 01 for bulk-import smoke tests.

Deterministic synthetic CSV batch 02 for bulk-import smoke tests.

Deterministic synthetic JSON batch 02 for bulk-import smoke tests.

Deterministic synthetic CSV batch 03 for bulk-import smoke tests.

Deterministic synthetic JSON batch 03 for bulk-import smoke tests.

Deterministic synthetic CSV batch 04 for bulk-import smoke tests.

Deterministic synthetic JSON batch 04 for bulk-import smoke tests.

Deterministic synthetic CSV batch 05 for bulk-import smoke tests.

Deterministic synthetic JSON batch 05 for bulk-import smoke tests.

Deterministic synthetic CSV batch 06 for bulk-import smoke tests.

Deterministic synthetic JSON batch 06 for bulk-import smoke tests.

Deterministic synthetic CSV batch 07 for bulk-import smoke tests.

Deterministic synthetic JSON batch 07 for bulk-import smoke tests.

Deterministic synthetic CSV batch 08 for bulk-import smoke tests.

Deterministic synthetic JSON batch 08 for bulk-import smoke tests.

Deterministic synthetic CSV batch 09 for bulk-import smoke tests.

Deterministic synthetic JSON batch 09 for bulk-import smoke tests.

Deterministic synthetic CSV batch 10 for bulk-import smoke tests.

Deterministic synthetic JSON batch 10 for bulk-import smoke tests.

Deterministic synthetic CSV batch 11 for bulk-import smoke tests.

Deterministic synthetic JSON batch 11 for bulk-import smoke tests.

Deterministic synthetic CSV batch 12 for bulk-import smoke tests.

Deterministic synthetic JSON batch 12 for bulk-import smoke tests.

Deterministic synthetic CSV batch 13 for bulk-import smoke tests.

Deterministic synthetic JSON batch 13 for bulk-import smoke tests.

Deterministic synthetic CSV batch 14 for bulk-import smoke tests.

Deterministic synthetic JSON batch 14 for bulk-import smoke tests.

Deterministic synthetic CSV batch 15 for bulk-import smoke tests.

Deterministic synthetic JSON batch 15 for bulk-import smoke tests.

Deterministic synthetic CSV batch 16 for bulk-import smoke tests.

Deterministic synthetic JSON batch 16 for bulk-import smoke tests.

Deterministic synthetic CSV batch 17 for bulk-import smoke tests.

Deterministic synthetic JSON batch 17 for bulk-import smoke tests.

Deterministic synthetic CSV batch 18 for bulk-import smoke tests.

Deterministic synthetic JSON batch 18 for bulk-import smoke tests.

Deterministic synthetic CSV batch 19 for bulk-import smoke tests.

Deterministic synthetic JSON batch 19 for bulk-import smoke tests.

Deterministic synthetic CSV batch 20 for bulk-import smoke tests.

Deterministic synthetic JSON batch 20 for bulk-import smoke tests.

Hourly order counts weekdays only (09–16 UTC) across three SAMPLE days.

Load readings with a repeated 01:00 local hour on fall-back DST — tests ambiguous timestamp handling.

Hourly load data skipping the 03:00 hour on DST spring-forward day — tests timezone/DST gap handling.

Two rows share the same timestamp key — tests deduplication and last-write-wins policies.

JSON array with duplicate timestamp keys for ingestion pipeline tests.

Timestamps at Unix epoch and classic 32-bit Y2038 boundary.

Series with an explicit null value at a missing sample point.

Sensor readings at irregular minute gaps — tests time-series resampling and gap detection.

JSON twin of irregular-interval sensor readings for charting library tests.

Readings spanning Feb 29 leap day — calendar edge case.

Sub-second millisecond timestamps for precision parsing tests.

Same nominal instant expressed in Z, -05:00, and +09:00 offsets.

CSV with NaN string and empty cells representing missing measurements.

Timestamps out of chronological order — tests sort-on-ingest behaviour.

Sparse event log in JSON Lines — two events hours apart for event-stream ingestion tests.

Pre-aggregated weekly totals JSON for rollup/chart tests.

A flight-schedule dataset — 30 flights with airline, origin/destination airports, departure/arrival times, aircraft, gate, and status. Synthetic data for testing travel apps, schedule parsers, and status boards.

The flight schedule as a JSON array — the format twin of the CSV, for import and display tests.

A 30-day daily weather forecast for one city — high/low temperature, condition, precipitation, wind, and humidity. Synthetic (seeded) data for testing weather widgets, chart tools, and time-series import.

The daily forecast as a JSON array — the format twin of the CSV, for import and charting tests.

A well-formed XML catalogue with nested elements and attributes — for testing XML parsers and XPath queries.

A YAML configuration file with nested mappings, sequences, inline lists, and comments — for testing YAML parsers.
Encoding matrix (UTF-8 BOM, UTF-16, CP1252, Shift-JIS, Latin-1), delimiter variants, fixed-width, ragged rows, quoted newlines, and domain mini-datasets (SaaS, POS, lab, marketing).
Schemas are documented and values are deterministic synthetic SAMPLE data — shaped like production exports without real customer PII.
Filter Browse by purpose encoding-detection or open the encodings subcategory under Data.
Yes — later waves add valid/invalid schema twins, pagination and webhook API fixtures, and irregular timestamp / DST-gap series. Filter by schema-testing or timeseries-testing.
We use Google Analytics and show ads via Adsterra. Non-essential cookies and ad scripts run only after you allow the matching categories. See our cookie policy.