> ## Documentation Index
> Fetch the complete documentation index at: https://docs.nimbleway.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Enrichment

> Send rows with gaps, get them back complete, every added value cited

**Enrichment** agents complete the data you already have. Send partial records in `input_data` (CRM leads missing funding stages, product rows missing specs), and the agent researches each gap on the live web and fills it. Your values are treated as ground truth and passed through untouched. Only the blanks get researched.

```text theme={"system"}
IN    "company_name":   "Acme Corp"
      "headquarters":   null
      "key_contacts":   null

      ── the agent researches only what's missing ──

OUT   "company_name":   "Acme Corp"          · yours, untouched
      "headquarters":   "Shelton, CT"        · cited: acme.com
      "key_contacts":   [{"name": "..."}]    · cited: acme.com/leadership
```

## Example Request

An enrichment run needs the rows (`input_data`) and the shape (`output_schema`, on the request or the agent). The `lead-enrichment` template ships a schema covering company identity, headquarters, decision-makers, and buying signals:

<CodeGroup>
  ```python Python theme={"system"}
  agent = nimble.agents.create(template="lead-enrichment")

  run = nimble.agents.runs.create(
      agent.id,
      input="Fill in the missing fields for these companies.",
      input_data=[
          {"company_name": "Nimble", "headquarters": None, "key_contacts": None},
          {"company_name": "Bright Data", "headquarters": None, "key_contacts": None},
      ],
  )
  ```

  ```typescript TypeScript theme={"system"}
  const agent = await nimble.agents.create({ template: "lead-enrichment" });

  const run = await nimble.agents.runs.create(agent.id, {
    input: "Fill in the missing fields for these companies.",
    input_data: [
      { company_name: "Nimble", headquarters: null, key_contacts: null },
      { company_name: "Bright Data", headquarters: null, key_contacts: null },
    ],
  });
  ```

  ```go Go theme={"system"}
  agent, err := client.Agents.New(ctx, nimble.AgentNewParams{
      Template: param.NewOpt("lead-enrichment"),
  })

  run, err := client.Agents.Runs.New(ctx, agent.ID, nimble.AgentRunNewParams{
      Input: "Fill in the missing fields for these companies.",
      InputData: nimble.AgentRunNewParamsInputDataUnion{
          OfMapOfAnyMap: []map[string]any{
              {"company_name": "Nimble", "headquarters": nil, "key_contacts": nil},
              {"company_name": "Bright Data", "headquarters": nil, "key_contacts": nil},
          },
      },
  })
  ```

  ```bash CLI theme={"system"}
  nimble agents:runs create \
    --agent-id "$AGENT_ID" \
    --input "Fill in the missing fields for these companies." \
    --input-data '[{company_name: "Nimble", headquarters: null, key_contacts: null}, {company_name: "Bright Data", headquarters: null, key_contacts: null}]'
  ```

  ```bash cURL theme={"system"}
  curl -X POST "https://sdk.nimbleway.com/v2/agents/$AGENT_ID/runs" \
    --header 'Authorization: Bearer <YOUR-API-KEY>' \
    --header 'Content-Type: application/json' \
    --data '{
      "input": "Fill in the missing fields for these companies.",
      "input_data": [
        {"company_name": "Nimble", "headquarters": null, "key_contacts": null},
        {"company_name": "Bright Data", "headquarters": null, "key_contacts": null}
      ]
    }'
  ```
</CodeGroup>

<Note>
  `input_data` accepts a list of partial rows (or a single object) mirroring the output schema. An `output_schema` (on the request or the agent) is required.
</Note>

## Example Response

The result is `type: "json"`: your rows back, gaps filled:

```json theme={"system"}
{
  "type": "json",
  "content": [
    {
      "company_name": "Nimble",
      "website": "https://www.nimbleway.com",
      "headquarters": "New York, NY, United States",
      "key_contacts": [
        { "name": "Uri Knorovich", "title": "Co-founder & CEO", "seniority": "c_suite" }
      ],
      "buying_signals": ["Launched the Web Search Agents API (July 2026)"],
      "summary": "Nimble is an AI-native web data platform providing search, extraction, and research agent APIs."
    }
  ],
  "trust": {
    "confidence": "high",
    "reasoning": "High confidence - cells fill rate is 100% and trust per claim ratio is 94%",
    "claims": [
      {
        "path": "$[0].company_name",
        "confidence": "pre_existing",
        "reasoning": "Provided in input_data"
      },
      {
        "path": "$[0].headquarters",
        "confidence": "high",
        "reasoning": "Backed by a primary source (official)",
        "citations": [
          {
            "url": "https://www.nimbleway.com/about",
            "excerpts": ["Headquartered in New York"],
            "source_category": "official"
          }
        ]
      }
    ]
  }
}
```

## Trust in enrichment runs

Every value in the result carries a claim per JSON path in the [trust report](/nimble-sdk/web-search-agents/trust). The grades distinguish your data from researched data:

| Confidence | Meaning in an enrichment run |
| - | - |
| `pre_existing` | Came from your `input_data`, carried over unchanged |
| `high` / `medium` / `low` | Researched, with citations and excerpts |

For example, `$[0].headquarters` carries a citation and a `high` grade, while `$[0].company_name` is marked `pre_existing`. Route low-confidence fills to review and sync the rest into your CRM, with source URLs alongside.

Two additional rules:

* The run's overall grade counts only researched values. `pre_existing` data is passed through, never graded.
* A gap the agent could not fill comes back as a cited `null` ([verified absence](/nimble-sdk/web-search-agents/trust#trust-for-structured-outputs)), distinguishing "no funding data exists" from "not found".

## Use cases

* **CRM hygiene**: complete funding, headcount, and tech-stack fields across the pipeline, with buying signals like recent hiring flagged (`lead-enrichment`).
* **Financial datasets**: fill valuation, investor, and filing gaps from primary sources (`financial-intelligence`).
* **Product catalogs**: complete specs, pricing, and availability across competitor listings (`ecommerce-intelligence`).

To enrich thousands of rows on a schedule, hand the same agent to [Jobs](/nimble-sdk/agentic/jobs): CSV or Parquet in, enriched rows delivered to your warehouse.

<Card title="Trust" icon="badge-check" href="/nimble-sdk/web-search-agents/trust">
  How per-path claims, citations, and `pre_existing` fit together
</Card>


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.