Export types

Once a nest completes, you turn it into output your shop can use — cut files, renders, reports, remnant geometry. This page covers the export endpoints, the export types you can ask for, and — importantly — how each one is delivered, because it is not the same for all of them.

Exports are keyed on a completed job. You need its RequestId and the ResultId (ResultIdentity in the webhook payload and in GET /v1/nesting/status) that identifies the specific result you want to export.

The endpoints at a glance

Endpoint	Delivery	You get
`GET`/`POST /v1/nesting/export`	Async → your webhook	A production export, of the type you pick (see below). Use `POST` to supply `Runtime` render settings on the call.
`GET /v1/nesting/exportquotenest`	Async → your webhook	A quote-oriented export
`GET /v1/nesting/export/cached`	Synchronous (pull)	An export previously generated over SignalR
`GET /v1/nesting/render/`	Synchronous	A rendered image of the layout, in the response body

The distinction matters: render and export/cached hand you data back in the HTTP response. export and exportquotenest do not — they accept your request, return { "Success": true } immediately, and POST the finished export to a webhook URL you supply.

Export types (`ResponseType`)

GET /v1/nesting/export produces different output depending on the ResponseType you pass. This is the parameter that selects what kind of export you get. It accepts either the name or the integer. Each type is generated from a settings block you supplied on the original nesting request. If that block was not supplied, the export cannot be produced — and the request is now rejected up front (see Synchronous validation below) rather than accepted and failing silently on your webhook.

`ResponseType`	Int	Requires on the original request	Output delivered to your webhook
`Result`	`0`	—	Part-placement details for the result (the same shape as the nesting result).
`Render`	`1`	`RenderSettings`	A base64-encoded render (SVG or PNG) of the layout.
`DXF`	`2`	`DXFExportSettings`	A base64-encoded DXF file of the nested layout.
`ReportSource`	`3`	`ReportSourceSettings`	Data for report generation — statistics plus base64 renderings (material usage, per-sheet breakdown).
`RemnantExport`	`4`	`RemnantGenerationSettings`	A base64-encoded zip of DXF files representing the remnants the nest generated.
`Runtime`	`5`	see note	Information about the result together with a render.
`PartsExport`	`6`	`PartExportSettings`	A DXF export of the individual part geometry from the nesting request.

Runtime render settings. Unlike the other types, Runtime takes its render settings (ReportSourceRenderingSettings) from the export call, not from a block on the original request. Over a GET it falls back to the original request’s ReportSourceSettings (and is rejected if none were supplied). To supply the render settings on the call itself, POST to /v1/nesting/export with a ReportSourceRenderingSettings body — the POST value wins, falling back to the original request’s ReportSourceSettings when omitted.

How to request an export (webhook-delivered)

GET /v1/nesting/export is asynchronous. You call it with the job identifiers, the ResponseType, and a WebHookUri; the API queues the export and returns straight away. The export itself arrives later as a POST to your WebHookUri.

Call the export endpoint

Pass RequestId, ResultId, the ResponseType you want, and the WebHookUri to deliver to.

curl "https://dev.api.nestapi.com/v1/nesting/export?RequestId=THE_REQUEST_ID&ResultId=THE_RESULT_ID&ResponseType=DXF&WebHookUri=https://your.app/hooks/export" \
  -H "Authorization: Bearer YOUR_API_KEY"

Get the acknowledgement

A successful call returns { "Success": true, "Error": null }. This confirms the export was accepted (it passed synchronous validation and was queued), not that it is ready — nothing is in the response body. A request that fails validation returns an error status instead, with the reason in ResponseStatus.

Receive the export on your webhook

When the export is generated, NestAPI POSTs it to your WebHookUri. On success the body is the export itself (shape depends on the ResponseType); on failure it is a small fixed object with an error and a support reference. Treat it like any other webhook: respond 2xx quickly and process out of band. See Webhooks → Export deliveries for both payload shapes.

Exports are rate-limited per type. By default you may request each ResponseType once per result; asking again for an export you have already requested returns an error rather than a second delivery. Request each type you need once, and hold on to what you receive.

Query parameters

Parameter	Required	Notes
`RequestId`	Yes	The job’s id (`RequestId` in the webhook payload; returned from the nesting endpoint). Must be a non-empty GUID.
`ResultId`	Yes	The specific result to export (`Status.ResultIdentity` in the webhook payload / status). Must be a non-empty GUID.
`ResponseType`	Yes	Which export to produce — see the table above. Must be a defined export type.
`WebHookUri`	Yes	Where the generated export is `POST`ed. Must be an absolute HTTPS URL. Without it the export has nowhere to go.

Synchronous validation

The request is validated before it is queued, so a malformed or unsatisfiable export is rejected on the call with a clear ResponseStatus message, rather than being accepted with { "Success": true } and then failing quietly on your webhook. The checks, and the status they return:

Status	When
`400 Bad Request`	`RequestId` or `ResultId` missing/empty; `WebHookUri` missing or not an absolute HTTPS URL (plain HTTP is accepted only for a loopback host such as `localhost`, for local testing); `ResponseType` not a known export type; or the export type’s required settings block (see the table above) was not supplied on the original nesting request. For `Runtime`, no `ReportSourceRenderingSettings` were available (neither on the POST body nor as `ReportSourceSettings` on the original request).
`404 Not Found`	No completed nest exists for this key with that `RequestId`/`ResultId`, or the result is no longer available — results are held in memory for a limited time after completion, and once the payload has expired it cannot be exported.
`409 Conflict`	The nest exists but is not in an exportable state: it has not completed yet, or it failed.
`429 Too Many Requests`	The per-type export limit for this result has been reached (see the rate-limit note above).

A 2xx with { "Success": true } means the request passed all of these and was queued.

Supplying `Runtime` render settings (POST)

Because Runtime render settings (ReportSourceRenderingSettings) are a nested object, a GET query string cannot carry them — over GET, Runtime uses the original request’s ReportSourceSettings. To supply them on the export call, POST to /v1/nesting/export with the settings in the body:

curl -X POST "https://dev.api.nestapi.com/v1/nesting/export" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "RequestId": "THE_REQUEST_ID",
    "ResultId": "THE_RESULT_ID",
    "ResponseType": "Runtime",
    "WebHookUri": "https://your.app/hooks/export",
    "ReportSourceRenderingSettings": {
      "NestingRenderSettings": { "RenderFormat": "SVG", "xDimension": 1920, "yDimension": 1080, "BackColorARGB": "#FFFFFFFF", "OutlineLineColorARGB": "#FF000000", "AutomaticallyChoosePartFillColor": true },
      "PartPreviewRenderSettings": { "RenderFormat": "SVG", "xDimension": 400, "yDimension": 400, "BackColorARGB": "#FFFFFFFF", "OutlineLineColorARGB": "#FF000000", "AutomaticallyChoosePartFillColor": true }
    }
  }'

The POST value takes precedence; when omitted it falls back to the original request’s ReportSourceSettings. The POST form works for every other ResponseType too — the body simply carries the same identifiers you would otherwise pass on the query string.

Quote-nest exports

GET /v1/nesting/exportquotenest is the quote-mode equivalent and is also webhook-delivered. It takes just RequestId and WebHookUri (there is no ResponseType — the quote export is a fixed shape) and, like export, returns { "Success": true } on acceptance and delivers the result to your webhook. It applies up-front validation: a missing RequestId, a missing or non-absolute WebHookUri (400), or a RequestId with no quote nest for your key (404) is rejected on the call. (Unlike export, the quote webhook is not required to be HTTPS — an absolute URL is enough.)

curl "https://dev.api.nestapi.com/v1/nesting/exportquotenest?RequestId=THE_REQUEST_ID&WebHookUri=https://your.app/hooks/export" \
  -H "Authorization: Bearer YOUR_API_KEY"

Renders (synchronous)

GET /v1/nesting/render/ is the exception: it returns the render in the response body, so it is the one export you can fetch and use in a single call. Use it for previews in your UI or for operator sheets.

curl "https://dev.api.nestapi.com/v1/nesting/render/?RequestId=THE_REQUEST_ID&ResultIdentity=THE_RESULT_ID" \
  -H "Authorization: Bearer YOUR_API_KEY"

The response is a RenderResponse:

{
  "RenderFormat": "svg",
  "Base64EncodedRendering": "…",
  "xDimension": "…",
  "yDimension": "…",
  "ResultIdentity": "THE_RESULT_ID"
}

Cached exports (SignalR)

GET /v1/nesting/export/cached lets you pull an export back synchronously — but only for exports generated through a SignalR result-generation request. The webhook-delivered GET /v1/nesting/export path does not populate this cache, so asking export/cached for something you requested that way will always report not-ready. This endpoint pairs with the SignalR flow, not the webhook flow. It takes RequestId, ResultId, and ResponseType, and returns a CachedNestingExportResponse:

{
  "Ready": true,
  "RequestId": "…",
  "ResultId": "…",
  "ResponseType": "DXF",
  "PayloadJson": "…",
  "CreatedUtc": "…",
  "ExpiresUtc": "…"
}

When the export has not been generated (or has expired), Ready is false and Error explains why. Cached exports have a limited lifetime, so fetch promptly.

Choosing between them

Producing cut files for a won job → GET /v1/nesting/export with ResponseType=DXF (delivered to your webhook).
Reports / statistics for a job → GET /v1/nesting/export with ResponseType=ReportSource.
Recovering remnant geometry → GET /v1/nesting/export with ResponseType=RemnantExport.
Backing up a quote with a layout → GET /v1/nesting/exportquotenest.
Showing the nest in a UI, in one call → GET /v1/nesting/render/.
Pulling back an export you generated over SignalR → GET /v1/nesting/export/cached.

For the full parameter and response schemas, see the Nesting section of the API Reference.

Getting Started

Guides

Concepts

Account

API Reference

The endpoints at a glance

Export types (`ResponseType`)

How to request an export (webhook-delivered)

Query parameters

Synchronous validation

Supplying `Runtime` render settings (POST)

Quote-nest exports

Renders (synchronous)

Cached exports (SignalR)

Choosing between them

​The endpoints at a glance

​Export types (ResponseType)

​How to request an export (webhook-delivered)

​Query parameters

​Synchronous validation

​Supplying Runtime render settings (POST)

​Quote-nest exports

​Renders (synchronous)

​Cached exports (SignalR)

​Choosing between them

The endpoints at a glance

Export types (`ResponseType`)

How to request an export (webhook-delivered)

Query parameters

Synchronous validation

Supplying `Runtime` render settings (POST)

Quote-nest exports

Renders (synchronous)

Cached exports (SignalR)

Choosing between them