Connect your lab's software to Spreadu with scoped API keys.
The Print Lab API connects your lab's software to the albums your lab receives through Spreadu. Your software can find finished albums, download their production files, check that every byte arrived, tell Spreadu it has them and confirm its own order.
Start in Test mode in the Lab Portal's API settings. Active labs can create test keys and generate test exports while the sandbox rollout is enabled. A platform admin grants live access separately. Follow Test your integration for a complete walkthrough, scenarios, local webhooks and reference integrations.
The API base URL is https://api.spreadu.com/api/print-lab/v1.
The API reference and
OpenAPI document describe
every operation and name every shape (Export, ExportSummary,
ExportRevision, ExportFile, LabOrder and so on), so generated clients get
readable types. Desktop apps, WordPress plugins and other integrations use this
same public contract.
You need an active lab, a Full access test key from API settings and a terminal. Use Test mode to generate the first export yourself.
export SPREADU_KEY="<your-test-key>"
export API="https://api.spreadu.com/api/print-lab/v1"1. Check the key. GET /me returns your lab, the key's scopes and enabled
modules, plus mode: "test". Authenticated responses also carry Spreadu-Mode.
curl -s "$API/me" -H "Authorization: Bearer $SPREADU_KEY"2. Create work. Simulate a photographer's export. Save the returned
reference; the files are generated asynchronously.
curl -s -X POST "$API/sandbox/exports" \
-H "Authorization: Bearer $SPREADU_KEY" \
-H "Idempotency-Key: <unique-command-id>" \
-H "Content-Type: application/json" \
-d '{"scenario":"spreads-jpg"}'List exports you can download now and have not received yet. If generation is still running, wait briefly and try again.
curl -s "$API/exports?downloadable=true&received=false&limit=100" \
-H "Authorization: Bearer $SPREADU_KEY"Each item has a reference and a downloadableRevision.
Follow nextCursor until it is null.
Set REFERENCE to the returned reference and REVISION to its downloadable
revision (normally 1 for this new test export):
export REFERENCE="<returned-reference>"
export REVISION=13. Get download URLs for that exact revision.
curl -s -X POST "$API/exports/$REFERENCE/download-urls" \
-H "Authorization: Bearer $SPREADU_KEY" \
-H "Content-Type: application/json" \
-d "{\"revision\":$REVISION}"The response lists every production file and package with a url. Download
each one before expiresAt, 15 minutes after your request.
4. Check every file. Compare the SHA-256 of what you saved with the file's
checksumSha256:
sha256sum album.zip # on macOS: shasum -a 256 album.zip5. Record the receipt once every checksum matches.
curl -s -X PUT "$API/exports/$REFERENCE/receipt" \
-H "Authorization: Bearer $SPREADU_KEY" \
-H "Content-Type: application/json" \
-d "{\"revision\":$REVISION}"The response includes the reference, revision, receivedAt and changed.
That export now drops out of received=false. Repeating the call is safe. To
react to new albums instead of polling, follow the event feed
or receive webhooks.
Send the key in the Authorization header:
GET /api/print-lab/v1/me HTTP/1.1
Host: api.spreadu.com
Authorization: Bearer <your-api-key>Session cookies do not authenticate this API. Billing credentials are separate and cannot be used here.
Copy a new key when it is shown. Spreadu cannot show it again. Store it in your
application's secret storage, never in a public page or browser bundle. Keys
have no expiry. To rotate one, create a replacement, switch your application
to it, then revoke the old key. Revocation takes effect on the next request.
A lab can have up to 25 unrevoked keys.
Test keys begin spreadu_lab_test_ and live keys begin spreadu_lab_.
They use the same base URL and are isolated from one another's exports.
Modules control the capabilities enabled for a lab. core is always enabled.
The exports module is activated separately by a platform admin. Reserved
module names are catalog, prices, albums, orders and customers.
They are not available in v1. Covers will be parts of exports, rather than a
separate module.
Each key has at least one scope from the lab's enabled modules:
| Scope | Permission |
|---|---|
exports:read | Read exports and export events. |
exports:download | Request download URLs and record receipts. |
exports:confirm | Confirm an order and release a lab lock. |
webhooks:manage | Create and manage the key's own webhook endpoints (details). Part of core. |
sandbox:manage | Generate test exports and simulate corrections, withdrawal, order changes, warnings, expiry and reset. Test mode only. |
Choose Download only for read and download permissions, or Full access for every scope the lab's enabled modules offer. You can also choose scopes individually. A key cannot grant access to a module that is disabled for its lab.
The global API switch and the lab's API access must both be enabled.
Impersonated sessions can view settings but cannot change them. In the portal,
lab owners and managers manage webhook destinations; a key with
webhooks:manage manages only the endpoints it created. Platform admins manage
live API access and modules. Lab owners, managers and platform admins can create
and revoke API keys in either mode, once that mode is available.
Spreadu-Mode: live or test. Responses include x-request-id for troubleshooting and
Cache-Control: no-store.429 response
includes Retry-After; wait that long before retrying.The API adds no payments or price lists. Future monetary values will use
{ amountMinor: string, currency }, where currency is an ISO 4217 code.
Simulator writes accept an optional Idempotency-Key. Use it when retrying the
same command; see Test your integration.
Webhook creation is protected by its URL as a natural key.
Errors are JSON: { "defined": true, "code": "...", "status": 409, "message": "...", "data": { ... } }.
Branch on code, never on message. Each operation in the reference lists only
the codes it can return.
| Code | HTTP | Meaning | What to do |
|---|---|---|---|
BAD_REQUEST | 400 | A field, query value or cursor is invalid, or an unknown field was sent. | Fix the request. Restart a list without cursor if the cursor was altered. |
INVALID_API_KEY | 401 | The key is missing, malformed, unknown or revoked. | Check the header. Ask an admin for a new key if it was revoked. |
API_ACCESS_DISABLED | 403 | API access is off for your lab or globally. | Stop and ask your Spreadu contact. Retrying will not help. |
MODULE_NOT_ENABLED | 403 | The operation's module is not enabled. data.module names it. | Ask a platform admin to enable the module. |
INSUFFICIENT_SCOPE | 403 | The key lacks data.requiredScope. | Use a key with that scope. |
EXPORT_NOT_FOUND | 404 | No export with that reference belongs to your lab. | Check the reference. Another lab's export looks the same as a missing one. |
FILE_NOT_FOUND | 404 | A fileIds entry is not part of the requested revision. | Read the export again and request current file IDs. |
REVISION_NOT_FOUND | 404 | The receipt names a revision that was never published. | Record receipts only for revisions you downloaded. |
REVISION_NOT_DOWNLOADABLE | 409 | The revision is not the one this request accepts now. | Retry with data.downloadableRevision; when it is null, wait for an event. |
SANDBOX_BUSY | 409 | A test render currently owns the sandbox. | Wait for preparation to finish, then retry the same request and idempotency key where applicable. |
CURSOR_EXPIRED | 410 | The event cursor is older than the 30-day window. | Reconcile with GET /exports, then restart the feed without after. |
| (body limit) | 413 | The body exceeds 32 KB, returned as plain text. | Send fewer fileIds per request. |
RATE_LIMITED | 429 | Too many requests; the body is { error, message, retryAfter }. | Wait Retry-After seconds. |
A 5xx response means something went wrong on our side. Retry with backoff and
send us its x-request-id if it keeps happening.
data.downloadableRevision on REVISION_NOT_DOWNLOADABLE is the revision your
request would succeed with right now, so you can retry without reading the
export first. For downloads it equals the export's current downloadableRevision.
For confirmation it is also null while the album is not finalized, for example
while the photographer prepares a new revision.
GET /exports lists your lab's exports, newest first, up to limit (1-100,
default 50) per page. Follow nextCursor until it is null. The cursor never
encodes a filter, so you can change filters between pages. Filters combine with
AND:
| Filter | Matches |
|---|---|
downloadable=true | The current revision can be downloaded now. |
locked=true | Your lab confirmed the order and holds the lock (lockedAt set). |
confirmed=true | Your lab confirmed the order identifiers (labOrder.confirmedByLab). |
received=true | You recorded a receipt for the downloadable revision (receivedAt set). |
updatedSince=<ISO datetime> | updatedAt is at or after this time. |
orderNumber=<value> | labOrder.orderNumber equals the value exactly. |
externalOrderId=<value> | labOrder.externalOrderId equals the value exactly. |
Each boolean filter matches the summary field it names, and false matches
everything true does not, including exports without an order or without a
downloadable revision. updatedSince accepts Z or an offset; URL-encode a
+ offset as %2B.
Use GET /exports/{reference} for one export with all its revisions.
References accept either case and an optional hyphen.
Every list item, export detail and event carries the same summary:
| Field | Meaning |
|---|---|
reference, albumId | The export's reference and the album it came from. |
albumTitle | Photographer-chosen title from the newest revision. It can include a client's name. |
createdAt | When the album was set up for your lab, usually when the photographer created it. |
updatedAt | The latest change to the export, its order or its newest revision. |
downloadableRevision | The revision you can download now, or null. |
availableAt, downloadableUntil | When that revision became available and the last moment to download it. Null when nothing is downloadable. |
receivedAt | When you recorded receiving that revision, or null. |
lockedAt | When your lab locked the album for production, or null. |
correctionOpen | The photographer is preparing a correction. |
latestRevision | The newest revision's number and status, or null. |
photographer | { id, displayName }, or null while no revision is visible. |
labOrder | The order context, or null when there is none. |
photographer.displayName is the name frozen on the newest revision, the same
name the ZIP manifest carries. It can be null when the photographer has no name.
photographer.id is a stable ID for that photographer within your lab, so you
can group their albums. It is null when Spreadu no longer has them as your lab's
customer, for example after they deleted their account. No email addresses or
other contact details are included.
labOrder.orderedQuantity and orderedQuantityUnit are the album's length
in pages or spreads, not the number of books to print. orderedLength carries
the same value as { count, unit } and reads more clearly in new code; the two
older fields stay. orderedCopies is the number of printed copies the
photographer entered, from 1 to 999, or null. Photographers enter it when they
create the album or later in the editor's order settings, under the same rules
as the order number. It is informational: Spreadu never enforces it.
labOrder shows the current order. Each revision's order shows what was
frozen when that revision was submitted: { orderedLength, orderedCopies }, or
null when the album had no order then. Produce from the revision you downloaded.
Revision numbers can skip failed attempts. Only the current available,
unexpired revision is downloadable. Its parts contain individual production
files and its packages contain the ZIP and, for PDF output, the combined PDF.
Live v1 exports currently contain an INNER part. The cover-and-inner test
scenario also exercises a COVER part. Handle every returned part explicitly.
Previews are not production files and are not returned here. Files and packages
are empty when the revision cannot be downloaded.
Request URLs with POST /exports/{reference}/download-urls:
{ "revision": 2, "fileIds": ["<file-id>"] }Omit fileIds to request every production file and package in that revision,
or pass up to 500 IDs. One foreign file or an unavailable revision rejects the
whole request. Each issued URL is audited as the API key, not as a user.
Issuing a URL does not prove that a download completed; a receipt does.
URLs expire 900 seconds after request start. Check each downloaded file's
checksumSha256. R2 supports Range requests; to resume after a URL expires,
request new URLs for the remaining files. Store the revision alongside each
file so a newer export cannot silently replace files in a download already
in progress.
Product, spec, output and geometry come from the frozen revision. Later album edits do not change them.
geometry copies the stored inner specification without rounding. It is null
when the revision has no valid stored specification; optional missing dimensions
are null individually. Values ending in Px are pixels and are authoritative:
| Field | Meaning in the frozen inner specification |
|---|---|
dpi | Resolution used to interpret the stored dimensions. |
widthPx, heightPx | Stored inner layout width and height. |
pageWidthPx, pageHeightPx | Stored individual-page width and height, when present. |
trimWidthPx, trimHeightPx | Stored trim width and height, when present. |
innerBleedPx | Stored bleed at the inner edge, when present. |
outerBleedPx | Stored bleed at the outer edge, when present. |
spineWidthPx | Stored spine width, when present. |
geometry.mm repeats each dimension in millimetres, without the Px suffix:
width, height, pageWidth, pageHeight, trimWidth, trimHeight,
innerBleed, outerBleed and spineWidth. Each value is px / dpi * 25.4
rounded to 0.1 mm, and null where the pixel value is null. mm itself is null
only if the stored DPI is not positive. At 300 DPI,
widthPx: 7200 is width: 609.6. Use millimetres for people and pixels for
machines. Do not substitute live catalog measurements for the frozen geometry.
PUT /exports/{reference}/receipt with { "revision": 2 } tells Spreadu that
your lab has that revision's files. The key needs exports:download.
404 REVISION_NOT_FOUND.export.received
event. A repeat returns changed: false with the original receivedAt and
sends nothing.Each revision shows its own receivedAt. The summary's receivedAt refers to
the downloadable revision, so a new revision starts unreceived. The
photographer sees "Received by the lab" with the date in the editor's export
status, and your Lab Portal shows it on the album.
When your lab is ready to produce an export, confirm the exact revision with
PUT /exports/{reference}/confirmation. The key needs exports:confirm:
{
"revision": 2,
"orderNumber": "<your-order-number>",
"externalOrderId": null,
"externalOrderLineId": null
}orderNumber is required, must contain 1-120 characters after trimming and cannot
contain control characters. Supply both external identifier fields as trimmed
1-120 character strings or null. Confirmation can replace a photographer-entered number or an
earlier lab confirmation. It creates the order context if none exists, without
adding a length, copies or an ordered spread count. It never changes an existing
length, copies or the album's spreads.
The album must be finalized and the revision must still be the current,
downloadable revision. Otherwise the request returns 409 REVISION_NOT_DOWNLOADABLE
and changes nothing. Repeating the same confirmation while already locked returns
changed: false and creates no additional event.
Confirmation sets lockedAt. While it is set, the photographer cannot edit the
album, change its order context, open a correction or resubmit. Viewing and
permitted photographer downloads continue. Expiry, unavailable files, key
revocation and disabled API access do not release this lock.
To allow changes again, use DELETE /exports/{reference}/lock with
exports:confirm. A lab owner, manager or platform admin can also unlock from
the album in the Lab Portal, using their own session. An already unlocked album
returns changed: false. Unlocking preserves the order identifiers and their
source. labOrder.confirmedByLab reports whether the stored source is API;
use lockedAt, rather than that field, to determine whether editing is locked.
These confirmations identify the lab's order and protect its production files. They are not print confirmations and do not create billing records or payments.
GET /events starts at the oldest retained event. Save nextCursor and pass it
as after on the next request. Use wait=30 to wait for changes and limit
between 1 and 200. A lab can have five simultaneous waits per API process;
additional requests return immediately. Each wait counts as one API request.
The envelope is { id, type, version, sequence, occurredAt, data }.
data.export contains the export summary. export.available also includes
the full revision, so you can request its download URLs directly.
| Event | Change |
|---|---|
export.requested | A revision was submitted for preparation. |
export.available | A revision became available. |
export.withdrawn | A correction opened or files became unavailable. |
export.expiring | The revision is approaching its download deadline. |
export.expired | The download window ended. |
export.confirmed | The lab confirmed order identifiers or acquired the album lock. |
export.unlocked | The lab lock was released. |
export.received | The lab recorded receiving a revision's files; data.revision names it. |
Event bodies are stored when sequenced and never rewritten. Events sequenced
before v1.1 lack the summary and revision fields it added; treat a missing field
as unknown. export.received always carries the full summary.
Numbers are monotonic and gap-free across the lab's full stream. Batches follow what has committed when the sequencer reads; events within a batch follow creation time and ID, not strict producer commit order. Event data reflects the export when sequenced, so it can already include a subsequent change.
Scopes, enabled modules and an optional types filter restrict what a key can
see. Filtered views can have sequence gaps. For example, use
types=export.available&types=export.withdrawn; one value works too.
An empty response keeps the cursor unchanged. Events are retained for 30 days
after sequencing. On 410 CURSOR_EXPIRED, reconcile with /exports and start
a new feed without after.
Lab owners and managers can configure up to five endpoints in the Lab Portal's API settings. An integration can also manage its own endpoints with an API key. Use your own session: impersonated sessions and platform admins can view webhook settings and delivery history, but cannot save, rotate, enable, remove, test or resend webhooks.
Give each endpoint a label, an HTTPS URL and its event subscriptions. Choose
explicit event types or * for every current and future type in your lab's enabled
modules. URLs must use port 443, have no embedded credentials or fragment, and
resolve entirely to public addresses. IP-literal URLs, localhost and names under
.localhost, .local or .internal are refused. The same destination checks run
before every attempt, so changing DNS cannot turn an approved URL into a private
destination.
Copy the endpoint's whsec_... secret when it is shown on creation or rotation.
Store it with your receiver's secrets. It is separate from your API key and cannot
be shown again. After rotation, Spreadu includes signatures from the new and
previous secret for 24 hours, giving you time to update the receiver.
Webhooks use Standard Webhooks. Use an official verifier, such as the JavaScript library, with the endpoint secret, the exact raw request body and these headers:
| Header | Meaning |
|---|---|
webhook-id | Stable envelope ID used for deduplication. |
webhook-timestamp | This attempt's Unix timestamp in seconds. |
webhook-signature | One or more space-separated v1,<base64-signature> values. |
user-agent | Spreadu-Webhooks/1. |
The signed bytes are id.timestamp.body: the header ID, a dot, the timestamp
exactly as received, another dot, then the raw body. The signature is HMAC-SHA256
using the base64-decoded bytes after the secret's whsec_ prefix. JSON parsing
and re-serialization can change those bytes, even when the JSON has the same
meaning. Preserve the raw body for verification.
Verify the signature and timestamp before processing the event. A matching
supported signature is sufficient during the rotation overlap; do not require
both secrets to be configured in your receiver. Keep the verifier's timestamp
replay checks enabled, then deduplicate using webhook-id.
The body is the same event envelope as the feed, including its persisted
sequence and data. Delivery is at least once and can arrive out of order.
Use sequence for ordering, not arrival time. Recover missing events through
GET /events; the feed's scope, module and type filters can also explain gaps.
Return a 2xx status after safely recording the event for processing. Every other status, including 3xx, counts as failure. Redirects are never followed. Live response bodies are not read; Test mode captures a bounded preview for the delivery inspector. An attempt has a five-second connection limit and a ten-second total limit, including DNS and TLS setup.
An event gets up to eight attempts. Delays before attempts 2-8 are:
| Attempt | Delay after the previous failure |
|---|---|
| 2 | 1 minute |
| 3 | 5 minutes |
| 4 | 30 minutes |
| 5 | 2 hours |
| 6 | 6 hours |
| 7 | 12 hours |
| 8 | 24 hours |
Each scheduled delay has up to 10% jitter in either direction. A Retry-After
header on a 429 or 503 response can raise the delay to a maximum of six hours.
It never shortens an already longer scheduled delay. After the eighth failed
attempt, the delivery is DEAD.
API settings show the lab's last 50 delivery records, including attempt count,
HTTP status and error code. After fixing the receiver, resend a DEAD delivery;
you can also resend a SUCCEEDED one. Resend resets its attempt count while
preserving the webhook ID, event body and occurrence time. Each attempt gets a
fresh timestamp header and signature.
Disabling an endpoint cancels its PENDING deliveries. Removing it also removes
its delivery history. The global API switch or the lab's access being off stops
sending; events from disabled modules are not sent.
Send a test from the endpoint's controls to receive a ping. It uses one attempt
and the same signature verification as other webhooks. Its envelope is:
{
"id": "ping_<delivery-id>",
"type": "ping",
"version": 1,
"sequence": "0",
"occurredAt": "<test-created-at-in-UTC>",
"data": {}
}ping is webhook-only: it creates no event in the feed and consumes no stream
sequence. Real events start at "1". Never update your feed cursor from a ping.
Resending the test preserves its ID, body and creation time, with a fresh attempt
timestamp and signature.
An integration can add and maintain its own webhook endpoints, so nobody has to
paste URLs into the Lab Portal. Give the key the Manage webhooks permission
(webhooks:manage). It is part of Full access and not part of
Download only.
A key sees and manages only the endpoints it created. Any other endpoint answers
404 WEBHOOK_NOT_FOUND, whether a lab manager added it in the portal, another
key created it, or it belongs to another lab. Lab owners and managers still see
and manage every endpoint in the portal, where key-created ones show "Created by
API key" with the key's label. Revoking a key also disables every endpoint it
created and cancels their pending deliveries, so a leaked key cannot keep
receiving events after you revoke it. An owner or manager can re-enable such an
endpoint in the portal on purpose.
label: 1 to 60 characters.url: a public https:// address on port 443, at most 2048 characters, with
no credentials or fragment. Every DNS answer must be a public address. The
same check runs on every URL change and before every delivery.eventTypes: a list of event types, or ["*"] for every current and future
event. A key can subscribe only to events it may read itself: export.*
events need exports:read, and ["*"] needs every read permission the
current events require. Endpoints a key created receive only events that key
can read, so a future event type that needs a permission the key lacks is not
sent there. An empty list [] receives only test pings.https://Hooks.Example.com:443/in equals https://hooks.example.com/in.
Creating a second endpoint with the same URL answers 409 WEBHOOK_URL_EXISTS.
When your key created the existing one, data.webhookId names it. This
replaces an Idempotency-Key for create: if a create times out, send it
again, and a 409 with data.webhookId tells you the first attempt worked.
Its secret was only in the lost response, so call
POST /webhooks/{webhookId}/secret to get a new one before you receive
events. For the next 24 hours the unseen previous secret also still signs.whsec_...) appears only in the create and rotate
responses. Store it right away; it is never shown again.503 SERVICE_UNAVAILABLE and
change nothing. Retry later. Enabling, disabling, testing and deleting still
work.GET /api/print-lab/v1/webhooks
Authorization: Bearer spreadu_lab_...{
"items": [
{
"id": "cm3wh0000000000000000001",
"label": "Order sync",
"url": "https://hooks.example.com/spreadu",
"eventTypes": ["*"],
"enabled": true,
"createdAt": "2026-11-03T09:00:00.000Z",
"updatedAt": "2026-11-03T09:00:00.000Z",
"lastDelivery": {
"status": "SUCCEEDED",
"attemptCount": 1,
"lastStatusCode": 204,
"lastErrorCode": null,
"lastAttemptAt": "2026-11-03T09:01:12.000Z"
}
}
]
}lastDelivery is the endpoint's most recent delivery, or null before the
first one. Its status is PENDING, SUCCEEDED, DEAD (all retries failed)
or CANCELLED (the endpoint was disabled). lastErrorCode is one of
TIMEOUT, DNS_REJECTED, CONNECT_FAILED, TLS_FAILED, REDIRECT,
HTTP_STATUS, or null.
POST /api/print-lab/v1/webhooks
Content-Type: application/json
{ "label": "Order sync", "url": "https://hooks.example.com/spreadu", "eventTypes": ["*"] }201 Created returns the endpoint plus "secret": "whsec_...". New endpoints
are enabled.
Send only the fields you want to change: label, url, eventTypes or
enabled.
PATCH /api/print-lab/v1/webhooks/cm3wh0000000000000000001
Content-Type: application/json
{ "enabled": false }Disabling cancels deliveries that are still pending. Enabling again does not
bring them back; use GET /events to catch up. The response is the updated
endpoint, without a secret.
POST /api/print-lab/v1/webhooks/cm3wh0000000000000000001/secretReturns the endpoint plus the new secret. For the next 24 hours both secrets
sign every delivery (webhook-signature: v1,<new> v1,<old>), so you can switch
your receiver without missing an event.
POST /api/print-lab/v1/webhooks/cm3wh0000000000000000001/test{ "eventId": "ping_cm3dl0000000000000000001" }Your receiver gets a signed ping whose webhook-id header and body id equal
eventId. A ping is never part of /events and never moves your cursor. A
disabled endpoint answers 409 WEBHOOK_DISABLED. The result appears in
lastDelivery.
DELETE /api/print-lab/v1/webhooks/cm3wh0000000000000000001{ "id": "cm3wh0000000000000000001", "deleted": true }This also deletes the endpoint's delivery history. Deleting it again answers
404 WEBHOOK_NOT_FOUND.
| Code | Status | What to do |
|---|---|---|
INSUFFICIENT_SCOPE | 403 | Create a key with Manage webhooks. |
WEBHOOK_NOT_FOUND | 404 | Use an ID your key created (see GET /webhooks). |
WEBHOOK_URL_EXISTS | 409 | If data.webhookId is present, update that endpoint. Otherwise ask a lab owner or manager to manage the existing endpoint in the portal. |
ENDPOINT_LIMIT_REACHED | 409 | Delete an endpoint, or ask a lab manager to remove one. |
WEBHOOK_DISABLED | 409 | Enable the endpoint before sending a test. |
BAD_REQUEST | 400 | data.field is url (use a public HTTPS URL) or eventTypes (use events your key can read). |
SERVICE_UNAVAILABLE | 503 | Secret storage is unavailable. Nothing changed; retry later. |
Changes within v1 are additive. Clients must tolerate unknown fields, enum
values, event types and operations. A breaking change will use /v2, with
at least 12 months of overlap. Follow the changelog below when upgrading your
integration.
PUT /exports/{reference}/receipt and the export.received event.createdAt, updatedAt, availableAt, downloadableUntil,
receivedAt and photographer to the export summary.locked, confirmed, received, updatedSince, orderNumber
and externalOrderId filters to GET /exports.labOrder.orderedLength and labOrder.orderedCopies, and each
revision's frozen order and receivedAt. orderedQuantity is the album
length, not copies.geometry.mm, every dimension in millimetres.data.downloadableRevision to REVISION_NOT_DOWNLOADABLE.GET /webhooks, POST /webhooks,
PATCH and DELETE /webhooks/{webhookId}, secret rotation and tests, with
the webhooks:manage scope.GET /me, the public OpenAPI document and API reference.Allow analytics to help us improve these docs? We measure page visits and outgoing links. No session recordings. Privacy policy