Skip to content
AvraAvra
Esc
↑↓navigate↵open⌘Jpreview
On this page

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

Was this page helpful?