# netintel.dev Text-to-JSON

> netintel.dev Text-to-JSON is a paid API for AI agents from netintel.dev, paid per call via x402, $0.05/call, status unknown (last checked 2026-09-13).

Converts unstructured text into structured JSON using a provided schema, with grading, field validation, and schema conformance scoring

## Facts

- Endpoint: POST https://netintel.dev/text-to-json
- Price: $0.05/call
- Payment: x402
- Status: unknown
- Last checked: 2026-09-13
- Activations on Zero: 0
- Tags: x402
- Canonical page: https://www.zero.xyz/c/netintel-dev-text-to-json-b8c7d1b7
- Structured record (JSON): https://api.zero.xyz/v1/capabilities/cap_KWE_5xLjhMsCqg3dcKr48

Status and success rate cover calls made through Zero and Zero's own probes. Third-party monitors may report differently.

## How to call it through Zero

Zero handles the 402 payment challenge and records the run. With the Zero CLI installed (`npm i -g @zeroxyz/cli`):

```sh
zero fetch --capability netintel-dev-text-to-json-b8c7d1b7 -d '<json body>'
```

Example prompt: Parse this company bio into structured JSON: 'Acme Corp was founded in 2010 and has 250 employees across offices in San Francisco and London. It is a private firm.' — use a schema with fields: company, employees, is_public, locations, and founded_year.

## When to prefer this

Use this endpoint when you need to reliably convert unstructured or semi-structured natural language text into a validated JSON object conforming to a specific schema, and you want graded feedback on extraction quality. Prefer it over generic LLM JSON extraction when you need per-field population metrics, schema conformance scoring, and structured validation findings — particularly for business intelligence, data pipelines, or form-filling workflows.

## Known failure modes

- Malformed or missing schema causes extraction failure or low grade
- Text lacks sufficient information to populate schema fields, resulting in nulled fields and low score
- Ambiguous or contradictory text produces incorrect field mappings
- Overly complex nested schemas may not be fully supported
- Payment failure via x402 returns 402 before any processing occurs

## How this service works

Turn unstructured text into structured JSON matching a caller-supplied schema using Claude Haiku — the agent declares the fields and types it wants, and gets back populated JSON with values pulled from the text and coerced to the right types, so agents can structure any prose into the exact shape their pipeline expects.

## Output

Returns a graded JSON object including: a letter grade (A–F) and numeric score (0–100), the extracted result object with schema fields populated, a schema_match boolean, counts of fields populated vs. total fields in schema, fields_nulled count, cached flag, and an array of validation findings or anomalies.

## Request schema (JSON Schema)

```json
{
 "$schema": "https://json-schema.org/draft/2020-12/schema",
 "type": "object",
 "properties": {
  "input": {
   "type": "object",
   "properties": {
    "type": {
     "type": "string",
     "const": "http"
    },
    "method": {
     "type": "string",
     "enum": [
      "POST"
     ]
    },
    "bodyType": {
     "type": "string",
     "enum": [
      "json",
      "form-data",
      "text"
     ]
    },
    "body": {
     "type": "object",
     "properties": {
      "text": {
       "type": "string",
       "description": "The unstructured prose to extract structured data from. Max 10000 words or 50KB."
      },
      "schema": {
       "type": "object",
       "description": "A map of field name → type token. Supported tokens: string, number, boolean, date, string[], number[], object. Max 50 fields. Each field is extracted from the text as the declared type; output keys are forced to exactly these field names."
      }
     },
     "required": [
      "text",
      "schema"
     ]
    }
   },
   "required": [
    "type",
    "method",
    "bodyType",
    "body"
   ],
   "additionalProperties": false
  },
  "output": {
   "type": "object",
   "properties": {
    "type": {
     "type": "string"
    },
    "example": {
     "type": "object",
     "properties": {
      "result": {
       "type": "object",
       "description": "The extracted data: keys are exactly the schema field names, values pulled from the text and cast to the declared types, unfindable fields null."
      },
      "fields_in_schema": {
       "type": "number",
       "description": "Number of fields in the schema."
      },
      "fields_populated": {
       "type": "number",
       "description": "Number of non-null fields in the output."
      },
      "fields_nulled": {
       "type": "number",
       "description": "Number of null fields in the output."
      },
      "schema_match": {
       "type": "boolean",
       "description": "True when the model's output keys were exactly the schema field names. False when code had to force-conform (strip extra / add missing) keys."
      },
      "cached": {
       "type": "boolean",
       "description": "True if served from the in-memory cache."
      },
      "score": {
       "type": "number",
       "description": "Quality score 0-100."
      },
      "grade": {
       "type": "string",
       "description": "Letter grade A-F."
      },
      "findings": {
       "type": "array",
       "items": {
        "type": "string"
       }
… (truncated)
```

## Response schema (JSON Schema)

```json
{
 "type": "json",
 "example": {
  "grade": "A",
  "score": 100,
  "cached": false,
  "result": {
   "company": "Acme Corp",
   "employees": 250,
   "is_public": false,
   "locations": [
    "San Francisco",
    "London"
   ],
   "founded_year": 2010
  },
  "findings": [],
  "schema_match": true,
  "fields_nulled": 0,
  "fields_in_schema": 5,
  "fields_populated": 5
 }
}
```

## More

- Live health (JSON, refreshed every minute): https://www.zero.xyz/c/netintel-dev-text-to-json-b8c7d1b7/health.json
- [Zero catalog index](https://www.zero.xyz/llms.txt)
- [Other services from netintel.dev](https://www.zero.xyz/host/netintel.dev/llms.txt)