ShockAI Model API

Bring your models and your analysis
where the measurements are

ShockAI records what each blast actually did. Bring the models your team trusts, as constants, a formula, a workbook or a service you host, and your own way of processing a recording. Every answer is held to the readings, beside the platform standard. Our own models already run on the published contract you can build against today.

Read the concepts Talk to us about integrating

Partner previewv0

The Model API is in partner preview. We’re working with select partners across the industry’s analysis platforms to shape v1 before general availability.

Four ways to bring a model

Start from what your team already trusts

Every way ends in the same place: a model the platform runs on the blast’s case, answering with a P50 and a P95, held to what was measured. Pick the one that fits how your model lives today.

Early access
Your constants
Your site law or airblast law, with the constants you fitted. Enter them once; they run on every blast.
You bring
K and β, the scatter, and the range your fit holds over.
The platform
Runs them through the platform’s own site-law or airblast engine, near-field refusal and prediction intervals included.
Early access
Your formula
Type the equation your team uses. It runs as written and reads as an equation, not a black box.
You bring
The equation, its inputs, and a few answers your spreadsheet gives to check it by.
The platform
Checks it against your answers, typesets it on the model’s card and runs it on every blast.
Early access
Your workbook
The spreadsheet your engineers trust, turned into a model the platform runs.
You bring
The workbook and the cells that hold your answer.
The platform
Our engineers convert it with you on a call, so the workbook stays on your machine.
Early access
Your own host
Any model, in any language, on a server you control. We keep its address, its manifest, its public keys and its answers. Never the model.
You bring
A service that answers the Model API, started from our TypeScript or Python template.
The platform
Checks it with the conformance suite, sends each case signed and trimmed to what it declares, and keeps its answers.

Partner preview

Every way runs on the same published contract as our own models.

shockai/site-law@3.0.0sha256:a39b9b68…343c

Our site-law model on the published example: a 32-hole bench with 4 receivers. R4 sits beyond the fitted range, so its answer says so.

Predicted PPV at each receiver
Receiver	Scaled distance	P50 (mm/s)	P95 (mm/s)	Validity
R1	14	16.4	28.4	Within
R2	23	7.8	13.2	Within
R3	38	3.4	5.9	Within
R4	55	1.9	3.3	Extrapolated

R4: at most 444 kg per delay keeps its P95 under 5 mm/s.

01The case32 holes · 4 receivers · site law
02The modelOurs, or yours
03P50 and P953 declined, each with a reason
04Held to the readingAfter the blastUnder the P50 · Within the P95 · Above the P95Partner preview

Bring your own analysisEarly access

Process recordings your way, beside ours

How acceleration becomes velocity is a choice, and specialists make it differently. Tune the vibration processing chain on a simulated record with a known answer, or on a real one, save it as your team’s recipe and run it on your events. The platform’s standard analysis stays exactly as it is.

What you tune

The high-pass corner and its order
How the record is detrended
The band the spectrum is read in

What stays fixed

Every number comes from the platform’s own analysis service, the engine behind the standard.
A recipe that would cut real vibration inside your compliance curves is flagged before you can save it.
Results show beside the platform standard, flagged wherever the peak or the verdict differs.

Tune how a recording becomes velocity, on a real or simulated record. Save it as your team’s recipe and run it beside the platform standard.

What stays yours

Your model is your IP. We built around that.

The platform needs to run your model, not to hold it. Here’s what that means, and where the limits are.

Zero custody on your own host
Early access
We keep the address, the manifest, the public keys and the answers. The model, its files and its constants stay on your server.
Your workbook stays with you
Early access
We convert it with you on a call, so the file never leaves your machine.
Shared by grant, run-only
Early access
Give a client team your model to run. They see its card, never its body.
Beside the standard
Early access
Your answers sit next to the platform’s. Compliance reports keep citing the platform standard.

Honest limits

Zero custody isn’t zero knowledge. To run your model we send it a case and keep its answer, so we see how it behaves on the cases it answers.
A simple law can be worked back out from a few of its answers. Anyone you let run it could recover its constants: sharing is licensing with an audit trail, not secrecy.
When you run a model someone else hosts, your case travels to their server. You’ll see where before the first run.

Why run it here

The hard part of modelling is the data. We collect it.

Calibrated inputs, not assumed onesA case carries the site’s own fitted laws for ground vibration and airblast, with the fit statistics a prediction interval needs, beside the design, the receivers and their limits. The contract also defines seed waveforms, measured VoD and detonator logs, and cases will carry them as the platform fills them in. Your model calibrates on field data, not on rock properties nobody can measure.
Predictions scored against realityAfter the blast, each recorded prediction is held to the reading at the same receiver: under the P50, within the P95 or above it. The platform’s own models are scored this way, and in early access so are a team’s own, connected ones included. Bias and coverage over time, per site, come next.
Results where decisions are madeA model’s answers sit beside the platform’s own on the blast page, each kept with its model, version and case, and a movement answer is drawn over the blast in the Visualiser. Blast reports cite the platform’s own models.
One contract, every siteImplement five endpoints once, against a published OpenAPI 3.1 document and JSON Schemas. Every case states its data owner’s terms, every run carries an idempotency key, and an identical case is answered from the cache instead of run twice.

How a run worksPartner preview

From measured record to scored prediction

01The platform assembles a BlastCaseThe design, the receivers and their limits, the site’s fitted laws and the question being asked, hashed into a case id.
02It sends what your manifest declaresA signed POST /runs carrying only the inputs your model says it reads.
03You return a ModelResultTyped outputs with percentiles, a validity verdict and provenance, or a reason for each output you decline.
04The result is cached, shown and citedKeyed by case id and model version, shown on the blast page and cited in the blast report.
05The blast is fired and measuredPredicted and measured values are compared at every receiver that recorded.

What a model can answer

Fourteen output kinds, one contract

Each kind is a typed answer to a question blasting engineers already ask. The platform’s reference models answer the first ten. The rest are open to partners.

Peak particle velocityReference model
receiver_ppvAt structures, monitors and boundaries, with exceedance probability against the receiver’s limit.
Charge per delayReference model
max_chargeThe largest charge per delay whose design percentile stays under a receiver’s limit: the number a blast is planned to.
AirblastReference model
airblastPeak overpressure at receivers.
Near-field damageReference model
damage_envelopeDamage radii and envelopes for wall control and dilution.
Strain fieldReference model
strain_fieldPeak extension of the rock over a plan-view grid at the charges’ depth: where a blast strains the rock past its strength, and by how much.
FlyrockReference model
flyrock_zoneMaximum throw by mechanism, with clearance distances.
FragmentationReference model
fragmentation_curveSize distribution, X50 and X80.
Burden movementReference model
movement_fieldWhere each block of the burden starts and comes to rest, when it leaves and how long it takes, where its flight first comes down, and the muckpile it forms.
Hole diagnosisReference model
hole_diagnosisAfter the blast: what each hole did, read from the blast’s own ground-motion records and its firing record, with a confidence and the working behind it.
Strain amplitude fitReference model
strain_amplitudeAfter the blast: the factor on a damage model’s near-field amplitude that makes its radii the backbreak seen behind the back row, for the site’s later blasts to carry.
Ground-motion time historiesOpen for your model
receiver_waveformPredicted three-component traces, such as from seed-waveform superposition.
Frequency contentOpen for your model
receiver_spectrumPredicted amplitude spectra at receivers.
Vibration fieldOpen for your model
ppv_fieldPPV over a plan-view grid at a chosen percentile.
Timing optimisationOpen for your model
timing_proposalProposed firing times against a stated objective.

ConformancePartner preview

16 checks every model passes, ours first

The suite checks the contract’s promises, not your numbers: accuracy is scored against measurements, after the blast. Our own models pass it on every change; your service runs through it when it connects.

01The manifest is a valid document.manifest.valid
02An async model declares the keys its callbacks are signed with.manifest.async-declares-callback-keys
03Every result is a valid ModelResult.result.valid
04A result names the case it answered.result.pinned-to-case
05A result names the model and version that made it.result.pinned-to-model
06Every question the case asks is answered, or declined with a reason.result.every-question-answered
07Nothing is answered that wasn’t asked.result.only-what-was-asked
08An answer given hole by hole names the case’s own holes, once each, and a diagnosis leaves no charged hole out.result.holes-in-design
09A point a model sets moving comes down no later than it comes to rest.result.touchdown-within-flight
10A field that states its points as sources states one for every point that moves.result.sources-for-every-flight
11The model reads only the inputs its manifest declares.result.reads-only-declared-inputs
12The result says which inputs it read.result.declares-what-it-read
13The same case gives the same answer.result.deterministic
14Data the model doesn’t read changes nothing.result.ignores-undeclared-inputs
15The same bytes behind another link give the same answer.result.ignores-blob-uri
16A missing required input is declined, not guessed.result.declines-without-required-input

Reference models

Our models use the same interface

The platform’s own models were the first providers on the interface, and they pass the same conformance suite yours will. They are the platform standard: the answer every other model is shown beside.

Site lawshockai/site-law@3.0.0
Far-field peak particle velocity from the scaled-distance law fitted to the site’s own readings, with Student-t prediction intervals from the fit, and the largest charge per delay a receiver’s limit allows.
empiricalreceiver_ppvmax_chargeSyncIncluded
Airblast lawshockai/airblast@1.0.0
Peak overpressure from the cube-root scaled-distance law fitted to the site’s own microphone readings, with Student-t prediction intervals.
empiricalairblastSyncIncluded
Kuz-Ram fragmentationshockai/kuz-ram@1.0.0
Mean fragment size by Kuznetsov and a Rosin-Rammler distribution by Cunningham’s uniformity index, per hole and for the blast.
empiricalfragmentation_curveSyncIncluded
Flyrock rangeshockai/flyrock@1.0.0
Face-burst and cratering throw by Richards and Moore from each hole’s burden, stemming and charge per metre, with clearance distances.
empiricalflyrock_zoneSyncIncluded
Hole healthshockai/hole-health@2.0.0
What each hole of a fired blast did, read from the blast’s own ground-motion records and its detonator log: fired on time, late or early, not detected, weak or strong, each with a calibrated confidence and the hole’s own motion as the working behind it.
kinematichole_diagnosisSyncIncluded
Kinematic movementshockai/kinematic-movement@0.8.0
Where a bench blast throws its burden and how the muckpile settles: each hole’s rock launched by its charge at its designed firing time, down the firing-time gradient, its stemming heaved mostly upward, confined by the bench beside and behind so that it leaves only through the free face and over the bench top, rows behind the face thrown only as far as the rock ahead makes room, flown ballistically and piled at its angle of repose, rock the pile closes round resting within it.
kinematicmovement_fieldSyncIncluded
Strain damageshockai/strain-damage@0.4.0
Which rock a blast strained past its strength: every hole's column-source P wave, near field included, superposed at its firing time and judged in strain against Hoek–Brown's criterion through Hooke's law; per hole, the radius at which it is passed, and the peak extension over a plan-view grid at the charges' depth.
hybriddamage_envelopestrain_fieldstrain_amplitudeSyncIncluded

The shape of an integration

A sync run, end to end

The platform signs a request and sends a case; your service verifies the signature, runs its model and answers with a run. The case is the published example (a 32-hole bench with four receivers) as the platform sends it to a site-law model: trimmed to the inputs that model declares. Long lists are shortened here, and the signature is over exactly the text shown.

POST /shockai/v0/runs HTTP/1.1
Host: models.example.com
Content-Type: application/json
Idempotency-Key: run_01J8Z5V3Q4K7M2N9P6R8S0T1U3
ShockAI-Signature: t=1790000000,kid=kPrK_qmxVWaYVA9wwBF6Iuo3vVzz7TxHCTwXBygrS4k,ed25519=LhvdhnM12gb90YYEc4mzjYR6TTXEYH_W8OfLEtQRoYnOUu3meoOJma1M-yF1aa_t_LK7RNHjLBBIK4scdbamAw

{
  "case": {
    "specVersion": "0.1",
    "caseId": "sha256:a39b9b6879f0ada629e40e51724e0ca69b4aad0466969ea2da88c4461acc343c",
    "createdAt": "2026-09-26T00:00:00Z",
    "coordinateSystem": {
      "kind": "local",
      "name": "Bench 12 local grid",
      "gridBearingDeg": 0,
      "origin": {
        "latitude": -22.6012,
        "longitude": 117.8421
      }
    },
    "site": {
      "domains": []
    },
    "design": {
      "holes": [
        {
          "id": "H01",
          "row": 1,
          "column": 1,
          "collar": {
            "x": 0,
            "y": 0,
            "z": 0
          },
          "toe": {
            "x": 0,
            "y": 0,
            "z": -13
          },
          "diameterMm": 165,
          "domainId": "hard",
          "burdenM": 4.5,
          "spacingM": 5.5,
          "subdrillM": 1,
          "decks": [
            {
              "kind": "stemming",
              "topDepthM": 0,
              "bottomDepthM": 3.5
            },
            {
              "kind": "explosive",
              "topDepthM": 3.5,
              "bottomDepthM": 13,
              "productId": "bulk-emulsion",
              "massKg": 253.9
            }
          ],
          "delay": {
            "totalMs": 0,
            "surfaceMs": 0,
            "downholeMs": 0
          }
        },
        "… 31 more"
      ],
      "products": [],
      "maxInstantaneousCharge": {
        "massKg": 253.9,
        "windowMs": 8
      },
      "pattern": "staggered"
    },
    "receivers": [
      {
        "id": "R1",
        "name": "Pit rim",
        "kind": "monitor",
        "position": {
          "x": -80.8,
          "y": -210.8,
          "z": 0
        },
        "distanceM": 225.9,
        "distanceSource": "placement"
      },
      "… 3 more"
    ],
    "request": {
      "outputs": [
        "receiver_ppv",
        "max_charge"
      ],
      "percentiles": [
        50,
        95
      ],
      "designPercentile": 95,
      "seed": 20260926
    },
    "consent": {
      "purpose": "prediction",
      "retention": "none",
      "allowTraining": false
    },
    "calibration": {
      "siteLaw": {
        "metric": "ppv",
        "basis": "pvs",
        "scaling": "square_root",
        "k": 1140,
        "beta": 1.6,
        "sigmaLn": 0.3,
        "n": 24,
        "scaledDistance": {
          "min": 12,
          "max": 45
        },
        "fit": {
          "dof": 22,
          "meanLnScaledDistance": 3.2189,
          "sxx": 3.48
        },
        "frequencyBins": [
          {
            "log10SdMin": 1,
            "log10SdMax": 1.1667,
            "medianHz": 31,
            "count": 7
          },
          "… 2 more"
        ],
        "source": "platform_fit"
      }
    }
  }
}

The full request, as sent (JSON)Full example run (JSON)

In the closed beta

A model reaches the platform through a team

ShockAI is in closed beta. A team connects a model on a host it runs, and its answers are kept on that team’s blasts. The features that takes are ones we bring teams on to one at a time. This is where each one stands.

Team modelsBy invitation
Beta v0.2A team’s own models, listed on its Models page in team settings and run beside the platform’s on the projects that pick them.
Connected modelsBy invitation
Experimental v0.3A model on a host you run, called over the Model API. It needs Team models first.
Recorded model runsBy invitation
Beta v0.4The platform’s own models’ runs on the blast page, kept and scored. A team’s own models’ runs show there without it.
Movement layerBy invitation
Experimental v0.1A connected model’s burden movement, drawn over the blast in the Visualiser.
ShockAI VisualiserBy invitation
Beta v0.8The 3D scene the movement layer is drawn in. On a team it needs a Pro seat.

An owner or admin of the team asks for a feature that is by invitation, and switches on one that is the team’s own, under Settings, in Beta features. We reply to the team. With Team models comes the team’s model namespace, which ShockAI assigns: the first part of every model id the team publishes.

Host your model

Two ways in

Partner preview

Integrate your product

You build blast-modelling, fragmentation, geotechnical or design software. Work with us on the v0 contract, start from a template host, and connect.

Start a conversation

Early access

Bring your team’s models

Constants, a formula, a workbook, a service you host or your own processing. Tell us what you have; early access opens team by team.

Ask for early access

Bring your models and your analysiswhere the measurements are

Start from what your team already trusts

Your constants

Your formula

Your workbook

Your own host