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

# Dregs API

The Dregs API ingests tracking events and returns fraud scores and risk analysis for the identities and devices behind them. It records identities, groups them, links their devices by fingerprint, and keeps a score history and analysis for each, while escalation rules and notification channels flag the identities that cross a threshold. Datasets and mappings feed the scoring, and a set of dashboard endpoints summarize score distribution, rule activity, and which identities need attention.

## For AI agents

Send tracking events to score identities and devices for fraud risk, read their scores and analysis, and manage escalation rules that flag risky activity.

## Scope

Does not process payments, verify identity documents, or chargeback-dispute transactions. Use for fraud scoring, risk analysis, and escalation only.

## Capabilities

- Send tracking events that score the identities and devices behind them
- Read fraud scores, score history, and analysis for an identity
- Group identities and manage their device links by fingerprint
- Define, preview, and manage escalation rules that flag risky identities
- Review and update escalations and read an escalation summary
- Manage notification channels and inspect their delivery history
- Maintain datasets and mappings that feed the scoring

## Use cases

### Agent-driven fraud triage

An AI agent connected through Jentic pulls the identities that need attention, reads each one's fraud score and analysis, and reviews the open escalations so an analyst starts the day with the riskiest cases summarized rather than scrolling a dashboard. The agent reads the scoring and escalation data on demand and highlights what changed.

Example prompt: List the identities flagged as needing attention, read each one's latest score, and summarize the open escalations

### Event ingestion and scoring

Applications send user and device events to Dregs so each identity is scored for fraud risk as activity happens. The event-ingest endpoint accepts either the secret key or a browser-safe public key, and the resulting score and analysis are then readable per identity and device.

Example prompt: Send a tracking event for an identity, then read the identity's updated score and its device links

### Escalation rule management

Risk teams define escalation rules that flag identities crossing a threshold, preview a rule before enabling it, and route matches to notification channels. Dregs exposes list, create, preview, and update operations for rules plus the escalations they produce.

Example prompt: Preview an escalation rule that flags identities above a risk threshold, then create it if the preview looks right

### Risk dashboards and summaries

Teams read Dregs dashboard endpoints to track score distribution, rule activity, and recently active identities over time. These summaries give an agent the aggregate picture it needs to report on fraud trends without re-deriving them from raw events.

Example prompt: Read the score-distribution and rule-activity summaries and report how risk has shifted

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/api/events` | Receive a tracking event |
| GET | `/api/identities/{id}/scores` | Get scores for an identity |
| POST | `/api/identities/{id}/actions/analyze` | Analyze an identity |
| GET | `/api/devices/{fingerprint}` | Get a device by fingerprint |
| GET | `/api/escalations` | List escalations |
| POST | `/api/escalation-rules` | Create an escalation rule |
| GET | `/api/dashboard/stats` | Read dashboard stats |

## Key resources

- **Identities** — Get, update, group, and link identities and read their scores, history, reviews, and analysis
- **Events** — Ingest tracking events that drive scoring and read individual events
- **Devices** — Look up and update devices by fingerprint
- **Escalations** — List and update escalations and manage the rules that produce them
- **Channels** — Create and test notification channels and read their deliveries
- **Dashboard** — Read score distribution, rule activity, stats, and attention summaries

## 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:** 64 / 100
- **Maturity:** AI-Aware
- **Dimensions:**
  - Foundational Compliance: 87 / 100
  - Developer Experience & Jentic Compatibility: 62 / 100
  - AI-Readiness & Agent Experience: 46 / 100
  - Agent Usability: 93 / 100
  - Security: 60 / 100
  - AI Discoverability: 71 / 100
- **View full report:** https://jentic.com/apis/dregs.com/dregs/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 Dregs by hand means handling its Bearer auth, keeping the admin secret key off the browser while allowing the public key on the event and device endpoints, and managing escalation rules and channels yourself. Through Jentic you install once, import Dregs from the API Directory, store the key once, and your agent calls it.
- **Permission scoping:** Dregs carries identity, device, and escalation ids in the URL path, so a rule can pin your agent to the operations you pick, such as ingesting events and reading scores. You choose the operations it may call, so destructive ones like deleting an escalation rule or a channel are not included unless you add them.
- **Credential handling:** Your Dregs secret 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.
- **Discovery method:** Agents search Jentic by intent such as 'read fraud scores for an identity' or 'send a tracking event', and Jentic returns the matching Dregs operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **Sift** — Machine-learning fraud scoring and decisioning, an alternative to Dregs for identity and device risk.
- **Truora** — Background checks and identity verification that complement Dregs' behavioral fraud scoring.
- **Onfido** — Document and biometric identity verification that pairs with Dregs' ongoing risk scoring.

## FAQ

### What authentication does the Dregs API use?

The Dregs API authenticates with a secret key sent as a Bearer token in the Authorization header per its OpenAPI spec. A browser-safe public key, also sent as a Bearer token, is additionally accepted on the event-ingest and device-read endpoints. Through Jentic the keys are stored once and injected at call time so they never enter the agent's prompt.

### Can I read fraud scores for an identity with the Dregs API?

Yes. Each identity exposes its current scores, score history, reviews, links, and analysis, and you can request a fresh analysis or review through dedicated action endpoints. Devices are read by fingerprint and carry their own risk signals.

### What are the rate limits for the Dregs API?

The OpenAPI spec does not publish fixed rate limits. Check the Dregs dashboard and documentation for the limits that apply to your team's credentials before sending high volumes of events.

### Is there a Dregs API MCP server?

You don't need an MCP server to give your agent the Dregs API. Jentic connects it directly from the API Directory: import it, store your key once, and your agent sends events and reads scores on demand without loading another server's tool definitions into its context.

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

Yes. Write a rule that allows only the event-ingest and score-read operations, so the agent can submit events and read fraud scores but cannot change escalation rules or delete channels, and every call it makes is logged for review.

### How do I triage fraud risk with the Dregs API through Jentic?

Search Jentic for 'read fraud scores for an identity', add the Dregs API from the directory, and store your secret key once; your agent can then pull flagged identities and read their scores on demand. To run it on your own infrastructure, install Jentic One from its GitHub repo.