canonical: https://jentic.com/apis/hedgespecialty.com/hedgespecialty

# Hedgespecialty Hedge Submission API

The Hedge Submission API submits commercial insurance risks to Hedge programmatically and tracks each one from marketing to quote and bind. You create a submission from structured JSON or send free text and PDFs to the intake endpoint, and Hedge matches appetite and opens three market lanes: Instant Quote, Binding, and Specialty. From there you read the markets being tried, answer outstanding requirements, act on released quotes, and request a bind, all scoped to your own brokerage by the access token.

## For AI agents

Submit a commercial insurance risk to Hedge, then track its markets, quotes, and requirements and request a bind, all scoped to one brokerage. Turns a broker's email-style placement into structured API calls.

## Scope

Does not sell insurance direct to consumers, underwrite risk, or process claims. Use for submitting commercial insurance risks through a broker and tracking them to quote and bind only.

## Capabilities

- Submit a commercial insurance risk as free text, PDFs, or structured JSON and start marketing it
- Track a submission across its Instant Quote, Binding, and Specialty market lanes with asks, assumptions, and released quotes
- Answer Hedge's outstanding requirements and carrier application questions in a batch or per session
- Request and submit bind requests on a released quote, attaching pre-bind contingency documents
- Check market appetite for a class of business by line, state, and NAICS before submitting
- Read your brokerage's bound policies, payment status, and book of insureds

## Use cases

### Agent-Driven Insurance Submission

An AI agent working a broker's book calls the Hedge Submission API through Jentic to place a commercial risk: it creates a submission from structured JSON or sends free text and PDFs to the intake endpoint, and Hedge immediately matches appetite and opens the Instant Quote, Binding, and Specialty lanes. The agent then polls the submission's markets and quotes, answers outstanding requirements, and tracks bind readiness, acting on the same thread a human broker would receive by email. A machine credential names a producer_email so every submission is attributed.

Example prompt: Create a submission for a general liability risk, poll its markets for released quotes, answer any outstanding requirements, and report bind readiness

### Appetite Check Before Placement

Before sending a risk, a brokerage checks which carriers will consider it by searching appetite by line of business, state, and class. The Hedge Submission API returns the programs Hedge would try and the supplemental questions a risk needs, so a broker can qualify a placement and gather answers up front instead of after a decline. This turns a cold submission into one that markets cleanly.

Example prompt: Search appetite for a restaurant general liability risk in Texas and return the programs Hedge would approach

### Bind and Policy Retrieval

Once a quote is released, a broker requests a bind, attaches any pre-bind contingency documents, and submits the bind request to Hedge for placement, then retrieves the bound policy and its documents. The Hedge Submission API exposes bind readiness, bind requests, and the brokerage's bound policies with downloadable PDFs, so the whole place-to-bind step runs without leaving the broker's own system. Payment and invoice status is available on the same rail.

Example prompt: Create and submit a bind request for a released quote, then download the bound policy document PDF

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/broker/submissions` | Create a submission from structured JSON |
| POST | `/broker/intake` | Send Hedge a risk as free text and/or PDFs |
| GET | `/broker/submissions/{submission_id}/markets` | The markets being tried, with asks, assumptions, and quotes |
| GET | `/broker/submissions/{submission_id}/quotes` | Every released quote on a submission, with each lane's status |
| POST | `/broker/submissions/{submission_id}/bind-requests` | Request to bind a released quote |
| GET | `/broker/submissions/{submission_id}` | Get one submission with status, markets, and documents |
| POST | `/broker/appetite/search` | Structured appetite search by query, lines, and state |
| GET | `/broker/policies` | List your brokerage's bound policies |

## Key resources

- **Submissions** — Create and track commercial risk submissions, their markets, quotes, thread, events, and requirements
- **Appetite** — Check market appetite, search placements by line and state, and preview the markets Hedge will approach
- **Binding** — Create, list, and submit bind requests and attach pre-bind contingency documents
- **Policies** — List and retrieve bound policies and download their document PDFs
- **Market access** — View and toggle the markets, programs, and lines a brokerage can quote through Hedge

## AI readiness

This API is usable in Jentic One now. Its AI-readiness score against Jentic's framework shows where it stands today and where improvements would make it even easier for agents to use.

- **Score:** 59 / 100
- **Maturity:** Foundational
- **Dimensions:**
  - Foundational Compliance: 41 / 100
  - Developer Experience & Jentic Compatibility: 62 / 100
  - AI-Readiness & Agent Experience: 46 / 100
  - Agent Usability: 91 / 100
  - Security: 85 / 100
  - AI Discoverability: 78 / 100
- **View full report:** https://jentic.com/apis/hedgespecialty.com/hedgespecialty/scorecard
- **How the score is calculated:** https://docs.jentic.com/reference/api-readiness-framework/overview/
- **More about the dimensions:** https://docs.jentic.com/reference/api-readiness-framework/specification/#dimensional-model-overview

### Score it yourself

Every API in the directory is allowlisted, so you can re-score it with no key required.

- **Score your own API:** https://jentic.com/scorecard.md
- **Scoring CLI agent skill:** https://github.com/jentic/jentic-api-scorecard/blob/main/skills/jentic-api-scorecard/SKILL.md

```sh
npx @jentic/api-scorecard-cli score <openapi-url>
```

## Why Jentic

- **Setup:** Wiring the Hedge Submission API by hand means implementing OAuth 2.1 with PKCE for broker users or the client_credentials grant for machine clients, naming a producer_email on machine submissions, and pointing at the right production or staging host. Through Jentic you install once, import it from the API Directory, store the credential once, and your agent calls it.
- **Permission scoping:** Hedge issues tokens with two scopes, broker_mcp for read and broker_submit for write, and all access is already pinned to your brokerage by the token. A Jentic rule can go finer and allow only the operations your agent needs, so it can read submissions, markets, and quotes without being able to create bind requests or submit new risks unless you add those operations.
- **Credential handling:** Your Hedge OAuth credential is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'submit an insurance risk' or 'check market appetite', and Jentic returns the matching Hedge operation with its input schema so the agent creates a submission or requests a bind without reading the reference docs.

## Related APIs

- **Claim.MD** — Submits healthcare insurance claims to payers electronically, versus commercial property and casualty placement to carriers.
- **Stripe** — Collects premium payments and issues invoices that sit alongside a bound policy Hedge places.
- **PandaDoc** — Handles e-signature and document workflows for the forms a placement needs, such as applications and binders.

## FAQ

### What authentication does the Hedge Submission API use?

The Hedge Submission API uses OAuth 2.1, per its OpenAPI spec: broker users authorize through the authorization-code flow with PKCE, and machine clients exchange an API key for a token through the client_credentials grant. Access tokens are scoped to your brokerage and carry a broker_mcp read scope or a broker_submit write scope. Through Jentic the credential is stored encrypted by your own Jentic One instance and injected at call time, so it never lands in the agent's logs.

### Can I track a submission to quote and bind with the Hedge Submission API?

Yes. After you create a submission, the API returns the markets being tried in three lanes (Instant Quote, Binding, and Specialty), every released quote, and a bind-readiness summary. You answer outstanding requirements in a batch, then create and submit a bind request on a released quote, and retrieve the bound policy once Hedge places it.

### What are the rate limits for the Hedge Submission API?

The OpenAPI spec does not specify rate limits. Hedge also pushes submission events and thread messages to a registered webhook, so you can avoid tight polling; for current limits, see the Hedge API documentation at https://api.hedgespecialty.com/api/v1/docs.

### How do I submit an insurance risk through Jentic?

Search Jentic with a query like 'submit a commercial insurance risk', add the Hedge Submission API from the directory, and store your OAuth credential once. Your agent calls the create-submission or intake operation, then polls the submission's markets and quotes and answers any requirements. To run it on your own infrastructure, install Jentic One from its GitHub repo.

### Can I limit what my agent is allowed to do with the Hedge Submission API?

Yes. Write a rule that allows only the read operations, such as listing submissions and reading markets, quotes, and policies, so the agent can monitor placements but cannot create submissions, answer on your behalf, or request a bind unless you add those write operations, and every call it makes is logged. Hedge already scopes every token to your own brokerage, so there is no cross-tenant access to begin with.

### Is there a Hedge MCP server?

Yes, Hedge offers an MCP connector that uses the same broker OAuth flow. You can also connect the Hedge Submission API directly through Jentic: your agent gets the full 70-endpoint surface without loading another server's tool definitions into its context, your credential is injected at call time by your self-hosted instance instead of living in a config file, and your rules decide which operations the agent may call.