A customised FastEditor product becomes a print-ready file in four steps: Create Smartlink sends the shopper to the editor, the Add to Cart callback returns the design and its projectKey, Sale Notification reports the order, and File Delivery posts the print files to your callback URL. Persist the projectKey and return a 201.
Most FastEditor integration questions come down to one thing: where does my print file come from, and how do I know which order it belongs to? The answer is a four-step handshake between your backend and FastEditor. Once you can picture the whole loop, the individual API calls make a lot more sense.
On this page
The four-step handshake
Where the print file comes from, and how you know which order it belongs to.
Create Smartlink
Your backend posts the product and context to FastEditor and receives one URL. Redirect the shopper to it.
Add to Cart
The editor returns the shopper with an fe_cart_url parameter. Fetch it server-side to get the line items, including the projectKey.
Sale Notification
After checkout, post the order with each projectKey and your callbackUrl. This is what triggers file generation.
File Delivery
FastEditor posts the generated print files and proofs to your callback endpoint. Verify the X-Api-Key header and answer 201.
Two security checks are not optional: validate the fe_cart_url host, and verify the API key on delivery.
Start by generating a deeplink with the Create Smartlink endpoint (POST /api/smartlink). You tell FastEditor which product to open (via supplier + productAttributes, supplier + virtualSku, or a projectId to reopen a project) and pass optional context like country, currency, language, quantity, and your own userId.
You can also send a customAttributes object here. It comes back to you in the Add to Cart callback, which makes it useful for carrying correlation data through the flow. The response is a single URL; redirect the shopper to it. The same SmartLink URL works whether you present the editor as an iframe overlay or a full-page redirect, so this lifecycle is unchanged either way.
When the shopper finishes designing, FastEditor forwards them to your cart URL and appends a query parameter, fe_cart_url. That parameter is itself a URL. Make a GET request to it from your backend and you'll receive a JSON array of items to add to the cart.
The fields you'll lean on:
projectKey: FastEditor's unique identifier for the finished copy of the project. This is the value you must send back in the Sale Notification.projectId: the project identifier you can later feed to Create Smartlink to reopen the design.sku, quantity, price, currency, country, language, imageUrl, and any customAttributes you sent in Step 1.output: an array with one entry per used print position, holding preview URLs, print method, print area and artwork dimensions, PMS colours, and the customer's original uploads.Security gotcha #1: validate that the domain of the receivedfe_cart_urlmatches the expected value (*.fasteditor.com) before you call it. Don't blindly fetch a URL handed to you in a query string.
After checkout, call the Sale Notification endpoint (POST /webhook/notifyorder) to let FastEditor know print files should be generated. The body is an order with one or more orderItems and a callbackUrl.
curl -X POST "https://{api_domain}/webhook/notifyorder" \
-H "X-Api-Key: YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"orderId": "order_123",
"orderItems": [
{
"projectKey": "916",
"orderItemId": "item_6750898",
"quantity": "50",
"totalSaleValue": "59.99"
}
],
"callbackUrl": "https://printfiles.mystore.com"
}'Replace {api_domain} with your assigned API domain. The staging default is api.editor.staging.fasteditor.com; your production domain is provided with your API credentials.
Each order item requires three things: the projectKey from the Add to Cart callback, your own orderItemId, and the quantity. The top-level callbackUrl is required too. It's where the finished print files are delivered next. You can also include billingInfo / shippingInfo, which matter when FastEditor submits orders to the supplier directly.
This step, File Delivery, is a request to you. FastEditor generates the print files and POSTs them to the callbackUrl you supplied. Implement a handler to receive it.
The payload includes the projectKey (to match back to your order item), a files array of download URLs, and an output array: one object per page or section, each with:
name: identifies the page/section (e.g. front, back, bookCover, innerPages)printFiles: URLs to the generated print filesproofUrls: print proof files, provided for logo productsprintMethod: the print method used for that sectionFor logo products you may also receive uploads (the customer's original files, so you can check vectorization results) and the callbackUrl echoed back.
Security gotcha #2: FastEditor adds the X-Api-Key header to the File Delivery request so you can verify the sender. Check it. Your account manager shares this value at the start of the integration.Response gotcha: FastEditor checks for a201response status code from your endpoint to confirm the data was received and saved. Return201, not200, on success, or the delivery may be treated as failed.
Create Smartlink (POST /api/smartlink)
| -> redirect shopper to returned URL
v
Add to Cart (GET the fe_cart_url)
| -> receive items + projectKey (persist projectKey)
v
Sale Notification (POST /webhook/notifyorder)
| -> send projectKey + orderItemId + quantity + callbackUrl
v
File Delivery (FastEditor POSTs to your callbackUrl)
| -> verify X-Api-Key, save files, return 201
v
Print-ready files in handprojectKey the moment you receive it in the Add to Cart callback. It's required for Sale Notification.fe_cart_url domain (*.fasteditor.com) before fetching it.X-Api-Key header on inbound File Delivery requests.201 from your File Delivery handler on success.X-Api-Key run from your backend.The full lifecycle is documented in the web-to-print API, and the Shopify and WooCommerce connectors implement it for you if you would rather not build the calls yourself.
| Step | Direction | Endpoint | The field you must not lose |
|---|---|---|---|
| 1. Create Smartlink | You to FastEditor | POST /api/smartlink | customAttributes, your correlation data, comes back in step 2 |
| 2. Add to Cart | FastEditor to you | GET the fe_cart_url handed back | projectKey, the identifier you send in step 3 |
| 3. Sale Notification | You to FastEditor | POST /webhook/notifyorder | callbackUrl, where the print files will be delivered |
| 4. File Delivery | FastEditor to you | POST to your callbackUrl | projectKey again, to match files back to the order item |
Two checks are not optional: validate that fe_cart_url resolves to *.fasteditor.com before you fetch it, and verify the X-Api-Key header on the File Delivery request. Your endpoint must answer 201 or FastEditor treats the delivery as failed.
More articles in Developers & API.
After the shopper customises a product, you call the Sale Notification endpoint (POST /webhook/notifyorder) with the order's projectKey. FastEditor then generates the print files and posts them to the callbackUrl you provided, via the File Delivery webhook.
projectKey is FastEditor's unique identifier for a finished design. You receive it in the Add to Cart callback and must send it back in the Sale Notification so FastEditor can generate and deliver the correct print files for that order item.
Return 201. FastEditor checks for a 201 response from your endpoint to confirm the print-file data was received and saved correctly.