Avra Core
The delivery layer for Avra's models — live predictions and batch inference into the systems you run, with versions, webhooks, and access controls around them.
Avra Core is how Avra’s models reach your systems. It serves Avra RFM, Avra GFM, and the models built on them the same way, live or in batch, with the controls your team needs around them. It’s for builders: your engineering and data teams, and the Avra engineers who work alongside them.
The workflow is the same whichever model you call. You create an API key for a workspace, find the model and the version you want, read the inputs that version’s schema declares, and send them: one record at a time through the live API, or whole files through batch inference. Versions and aliases decide which version answers, webhooks tell your systems when something changes, and roles and logs record who did what.
How Core reaches your systems
Every model available to your organization has versions, and an alias such as production points at one of them. Your systems call a version directly or through its alias, live or in batch, and webhooks report events to your systems as they happen.
Live or batch
| Live predictions | Batch inference | |
|---|---|---|
| You send | One record per request, as JSON | Parquet or CSV files with many records |
| You get back | The outputs the version declares, in the response | One result.parquet per batch |
| Endpoints | POST /v1/api/prediction/{model_id}/{alias_or_version_id} |
POST /v1/api/files/upload, then POST /v2/api/batches |
| Timing | Synchronous: the answer comes back in the response | Asynchronous: poll the batch, or subscribe to webhooks |
| Limits | About 100 requests per 10 seconds per API key | Enabled per organization; doesn’t count against the prediction limit |
| Use it for | Onboarding, underwriting one application at a time | Nightly portfolio rescoring, list enrichment |
Use live predictions when a decision waits on the answer: an onboarding step or an underwriting call. Use batch inference for more than a few thousand records at once, such as rescoring a whole portfolio every night. You can use both against the same model: batch to score the book every night, and live for the new requests that arrive during the day.
Every output a model declares comes back the same way, on either path. GFM embeddings, for example, are one of the GFM’s outputs: fetch them live or in batch, then add them to the models you already run. See Build with embeddings.
Core’s limits are collected in Limits and quotas, with what happens when you reach each one.
The models it serves
Core serves every model available to your organization through the same endpoints. Avra RFM predicts your own targets from your own data, and Avra GFM returns probabilities of default and embeddings for Brazilian companies, through Core only. Downstream models, such as a credit model trained on GFM embeddings together with your features and outcomes, are served the same way. An adapted or fine-tuned copy of the RFM is released as a version like any other, exclusive to your workspace. See Models for how the models compare.
The controls around them
Versions and aliases let you promote, pin, and roll back. Webhooks report events for batches, model versions, workspaces, and API keys. Access comes from API keys scoped to a workspace, roles, and an audit log, all in the dashboard. The usage log records every prediction a workspace served. See Audit and usage logs.
| Control | What it does | Where |
|---|---|---|
| API keys | Authenticate every call, scoped to one workspace | Settings → Workspace → API keys |
| Versions and aliases | Decide which version answers a call | Models, on each model’s page |
| Roles | Decide who can move aliases, create batches, and manage webhooks | Roles and permissions |
| Webhooks | Send events to your endpoints over HTTPS | Alerts → Webhooks |
| Audit and usage logs | Record account activity and every prediction served | Observability |
Get started
Create an API key
In the dashboard, open Settings → Workspace → API keys in the workspace the key is for, create a key, and keep it in an environment variable such as AVRA_API_KEY.
Find the model
List the models available to your organization with GET /v1/api/models, then read a version’s schema with GET /v1/api/models/{model_id}/versions/{alias_or_version_id}.
Call it
Send the inputs the schema declares to POST /v1/api/prediction/{model_id}/production. See Live predictions, or the Quickstart for a first call, step by step.
Where to go next
Live predictions
Call a model one record at a time, handle errors, and retry safely.
Batch inference
Upload files, run a batch, and download the results.
Model versioning
Pin a version, follow an alias, promote, and roll back.
Webhooks
Receive events, verify signatures, and handle retries.
Models
Compare Avra RFM and Avra GFM, and find the one for your question.
Limits and quotas
Every rate limit, size limit, and expiration in one place.