6 APIs across 3 product groups. All share one credential.
| I want to... | Use | Why |
|---|---|---|
| Check patient eligibility or submit and status a claim | Stedi Healthcare | Runs real-time eligibility checks, claim status inquiries, and professional and institutional claim submissions in JSON or raw X12. |
| Attach a document to a healthcare claim | Stedi Healthcare Claims | Handles claim attachment files and raw X12 attachment submissions, which the main healthcare API does not cover. |
| Run eligibility for many members at once | Stedi Manager | Starts batch eligibility runs, polls them to completion, and returns batch items and per-check PDFs. |
| Look up which payer to route a transaction to | Stedi Payers | Searches and lists the payer directory and returns individual payer records by Stedi id. |
| Track a provider's enrollment with a payer | Stedi Enrollment | Creates, updates, lists, and exports provider enrollments and their supporting documents. |
| Inspect or retry the processing behind a transaction | Core | Lists executions, reads their faults and input, and retries failed events and executions. |
What agents get from Jentic-routed access to this vendor.
Setup
Wiring the six Stedi APIs by hand means configuring the Authorization header key against separate dated US regional hosts for healthcare, claims, enrollment, payers, and the core engine, and threading ids between them yourself. Through Jentic you install once, add the Stedi APIs you need from the Jentic API Directory, store the one API key, and your agent calls them.
Permission scoping
Your own rules decide which Stedi operations an agent may call, so a read-only agent can look up payers, check eligibility, and read enrollments while claim submission, enrollment deletion, and execution retries stay out of reach unless you add them. Where an API puts a resource id in the path, such as an enrollment or execution id, a rule can pin the agent to a single record.
Credential isolation
Specific to using Stedi APIs through Jentic.
What can an agent do across the Stedi APIs?
An agent can check patient eligibility, submit professional and institutional claims and their attachments in JSON or raw X12, poll claim status, run batch eligibility jobs, look up payers in the directory, track provider enrollments, and inspect or retry the executions that process these transactions. These span the healthcare, enrollment, payer, and core execution APIs.
Do the Stedi APIs share one set of credentials?
Yes. All six APIs use the same apiKey model, with a Stedi API key passed in the Authorization header, so a single credential covers eligibility, claims, enrollment, payer lookup, and the core execution engine.
Which Stedi API should I use for a given task?
Use the Stedi Healthcare API for eligibility, claim status, and claim submission; the Stedi Healthcare Claims API for claim attachments; the Stedi Manager API for batch eligibility; the Stedi Payers API for the payer directory; the Stedi Enrollment API for provider enrollments; and the Stedi Core API to inspect and retry the executions behind them.
Do the Stedi APIs support raw X12 as well as JSON?
Yes. The healthcare and claims APIs accept both JSON and raw X12 for eligibility checks, claim submissions, and claim attachments, so an agent can work in whichever format the downstream payer or workflow requires.
BOOK A DEMO
Browse thousands of APIs and connect them all to your agent with Jentic One. One layer, one credential — every API your agent needs.
For Agents
An agent can run patient eligibility checks, submit professional and institutional claims and their attachments in JSON or raw X12, poll claim status, batch eligibility runs, look up healthcare payers, track provider enrollments, and inspect the events and executions that process these transactions. It moves across Stedi's healthcare, enrollment, payer, and core execution APIs with one set of credentials.
Stedi packages healthcare EDI as modern JSON and raw X12 REST APIs, so an agent can check eligibility, submit claims, and track their processing without running an on-premise clearinghouse connection. Eligibility, claims, enrollment, payer lookup, and the execution engine are separate APIs that share one account, so an agent can compose a coverage-to-claim workflow from a single vendor.
Use for: Healthcare EDI transactions: eligibility checks, claim and attachment submission in JSON or raw X12, claim status, provider enrollment, payer directory lookup, and inspecting the executions that process them.
Not supported: clinical records, patient scheduling, general payment processing, communications, crm
Credentials: All six Stedi APIs use the same apiKey model, passing a Stedi API key in the Authorization header, so one credential covers the whole portfolio.
All 6 Stedi OpenAPI specs are third-party and indexed by Jentic, kept validated and agent-ready.
Stedi is a healthcare EDI and clearinghouse platform whose APIs handle eligibility checks, claim status inquiries, claim and attachment submission in JSON or raw X12, provider enrollment tracking, a searchable payer directory, and the underlying event and execution engine that runs these transactions. The six APIs in this portfolio cover the full path from checking a patient's coverage through submitting claims and monitoring the executions that process them.
Install Jentic One Beta
Jentic One is a self-hosted execution layer for AI agents. It lets your agent call the Stedi APIs, or any other public or private API you need. You set the rules, the agent never sees your credentials, and every call is logged.
Two steps, two machines. Install the instance in a safe environment, then register your agent from wherever it runs.
Step 1: Jentic One Host machine
# On the machine that will host your Jentic One instance:
curl -fsSL "https://jentic.com/install.sh?src=apis&api=%2Fapis%2Fstedi.com" | shStep 2: Agent machine
# On the machine where your agent runs (keep this separate from the instance):
curl -fsSL "https://jentic.com/install.sh?src=apis&api=%2Fapis%2Fstedi.com" | sh
jentic register # connects your agent to your Jentic One instanceJentic One is in public beta. The setup above keeps your agent separate from the instance, which is what you want before using real credentials: an agent running as the same OS user as Jentic One can read its stored keys directly. Just evaluating? A single local install is fine to start. See the secure deployment guide for the tiers.
Once connected, ask your agent something like: “check patient eligibility and submit a healthcare claim”.
Each workflow spans multiple Stedi APIs. Jentic routes each operation to the right API automatically.
Verify coverage then submit the claim
An agent runs a real-time eligibility check for a patient, confirms active coverage, then submits the professional or institutional claim to the same payer, using the payer directory to resolve the correct destination.
Search the payer directory for the payer, run an eligibility check, then submit the claim if coverage is active
Stedi Healthcare + Stedi Payers
Submit a claim with a supporting attachment
An agent submits a claim through the healthcare API and adds the required supporting document as a claim attachment file or raw X12 attachment submission in the same run.
Submit the claim, then create the claim attachment file and submit it against that claim
Stedi Healthcare + Stedi Healthcare Claims
Batch eligibility then trace failures
An agent starts a batch eligibility run, polls it to completion, and for any failed items reads the execution faults and input from the core engine to diagnose and retry the transaction.
Start a batch eligibility run, poll for results, then read execution faults and retry any failed executions
Stedi Manager + Core
Enroll a provider then run its transactions
An agent confirms a provider's enrollment with a payer, resolving the payer from the directory, before running eligibility or claim transactions that depend on that enrollment being active.
Resolve the payer, list the provider's enrollments, and confirm active status before transacting
Stedi Enrollment + Stedi Payers
Your Stedi API key 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, which matters for the protected health information these APIs carry.
Intent-based discovery
Agents search the Jentic directory by intent such as 'check patient eligibility', 'submit a healthcare claim', or 'look up a payer', and Jentic returns the matching Stedi operation with its input schema so the agent calls the right endpoint across the portfolio without browsing the reference docs.
Can I compose a workflow across several Stedi APIs?
Yes. A common pattern is to resolve a payer from the directory, check eligibility, submit a claim with an attachment, and then trace any failed processing through the core execution engine. Because the APIs share one account, an agent can chain these steps without switching credentials.
Is Stedi a full clinical or scheduling system?
No. Stedi covers healthcare EDI and transaction processing: eligibility, claims, enrollment, payer data, and the execution engine. It does not manage clinical records, patient scheduling, or general payment processing outside the healthcare transaction flow.
All 4 are in the Jentic catalogue with the same one-credential, intent-search pattern.