ZPL रेंडरिंग API: HTTP के माध्यम से ZPL को PNG और PDF में

एक एंडपॉइंट ZPL को PNG या PDF में रेंडर करता है। यह Labelary के v1 API के साथ संगत है: समान पथ, हेडर और त्रुटियाँ।

लेबल रेंडर करें

GET  https://api.openzpl.com/v1/printers/{dpmm}/labels/{width}x{height}/{index}/{zpl}
POST https://api.openzpl.com/v1/printers/{dpmm}/labels/{width}x{height}/{index}
POST https://api.openzpl.com/v1/printers/{dpmm}/labels/{width}x{height}/

POST के साथ, ZPL को कच्चा अनुरोध शरीर के रूप में या file नाम के मल्टीपार्ट फ़ॉर्म फ़ील्ड के रूप में भेजें।

API कुंजी

बिना कुंजी के आप प्रति IP पता 3 लेबल प्रति दिन प्राप्त करते हैं, जो इसे आज़माने के लिए पर्याप्त है। अपने डैशबोर्ड से एक कुंजी के साथ, इसे X-API-Key हेडर में भेजें और आपके कार्यक्षेत्र की योजना की सीमाएँ लागू होती हैं।

curl https://api.openzpl.com/v1/printers/8dpmm/labels/4x6/0/ \
  -H "X-API-Key: oz_live_…" --data-binary @label.zpl > label.png

उदाहरण

प्रत्येक label.zpl भेजता है, label.pdf को सहेजता है और यदि कुछ गलत होता है तो API का त्रुटि संदेश दिखाता है। PNG के लिए, image/png के लिए अनुरोध करें और URL में लेबल का अनुक्रमांक (/0/) जोड़ें।

• cURL
• Python
• Node.js
• PHP
• C#
• Java
• Go
• Ruby
• PowerShell

curl https://api.openzpl.com/v1/printers/8dpmm/labels/4x6/ \
  -H "Accept: application/pdf" \
  --data-binary @label.zpl --fail-with-body -o label.pdf

import requests  # pip install requests

with open("label.zpl", "rb") as f:
    res = requests.post(
        "https://api.openzpl.com/v1/printers/8dpmm/labels/4x6/",
        data=f.read(),
        headers={"Accept": "application/pdf"},
        timeout=30,
    )
if not res.ok:
    raise SystemExit(res.text)
with open("label.pdf", "wb") as f:
    f.write(res.content)

// Node.js 18+; save as label.mjs
import { readFile, writeFile } from "node:fs/promises";

const res = await fetch("https://api.openzpl.com/v1/printers/8dpmm/labels/4x6/", {
  method: "POST",
  headers: { Accept: "application/pdf" },
  body: await readFile("label.zpl"),
});
if (!res.ok) throw new Error(await res.text());
await writeFile("label.pdf", Buffer.from(await res.arrayBuffer()));

<?php
$ch = curl_init("https://api.openzpl.com/v1/printers/8dpmm/labels/4x6/");
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_POSTFIELDS => file_get_contents("label.zpl"),
    CURLOPT_HTTPHEADER => ["Accept: application/pdf"],
    CURLOPT_RETURNTRANSFER => true,
]);
$pdf = curl_exec($ch);
if (curl_getinfo($ch, CURLINFO_RESPONSE_CODE) !== 200) {
    exit($pdf);
}
file_put_contents("label.pdf", $pdf);

using var http = new HttpClient();
var req = new HttpRequestMessage(HttpMethod.Post,
    "https://api.openzpl.com/v1/printers/8dpmm/labels/4x6/")
{
    Content = new StringContent(File.ReadAllText("label.zpl")),
};
req.Headers.Add("Accept", "application/pdf");

var res = await http.SendAsync(req);
if (!res.IsSuccessStatusCode)
    throw new Exception(await res.Content.ReadAsStringAsync());
File.WriteAllBytes("label.pdf", await res.Content.ReadAsByteArrayAsync());

// Java 11+
import java.net.URI;
import java.net.http.*;
import java.nio.file.Path;

public class Label {
    public static void main(String[] args) throws Exception {
        var req = HttpRequest.newBuilder(
                URI.create("https://api.openzpl.com/v1/printers/8dpmm/labels/4x6/"))
            .header("Accept", "application/pdf")
            .POST(HttpRequest.BodyPublishers.ofFile(Path.of("label.zpl")))
            .build();
        var res = HttpClient.newHttpClient()
            .send(req, HttpResponse.BodyHandlers.ofByteArray());
        if (res.statusCode() != 200)
            throw new RuntimeException(new String(res.body()));
        java.nio.file.Files.write(Path.of("label.pdf"), res.body());
    }
}

package main

import (
	"io"
	"log"
	"net/http"
	"os"
)

func main() {
	zpl, err := os.Open("label.zpl")
	if err != nil {
		log.Fatal(err)
	}
	req, _ := http.NewRequest("POST", "https://api.openzpl.com/v1/printers/8dpmm/labels/4x6/", zpl)
	req.Header.Set("Accept", "application/pdf")
	res, err := http.DefaultClient.Do(req)
	if err != nil {
		log.Fatal(err)
	}
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)
	if res.StatusCode != 200 {
		log.Fatal(string(body))
	}
	os.WriteFile("label.pdf", body, 0o644)
}

require "net/http"

uri = URI("https://api.openzpl.com/v1/printers/8dpmm/labels/4x6/")
res = Net::HTTP.post(uri, File.binread("label.zpl"), "Accept" => "application/pdf")
abort res.body unless res.is_a?(Net::HTTPSuccess)
File.binwrite("label.pdf", res.body)

Invoke-WebRequest -Method Post `
  -Uri "https://api.openzpl.com/v1/printers/8dpmm/labels/4x6/" `
  -Headers @{ Accept = "application/pdf" } `
  -InFile "label.zpl" -OutFile "label.pdf"

अनुरोध हेडर

सीमाएँ

• Without a key: 3 requests per second and 3 labels per UTC day, per IP address. With a free key from the dashboard: 20 labels per UTC day.
• Labels, not requests, count against the allowance (per UTC day on Free, per UTC calendar month on paid plans): every label rendered, ^PQ copies and PDF pages included. A 10-label PDF is 1 request and 10 labels.
• Every request: up to 50 labels, a 1 MB body, 15 inches per side, and 10 seconds of render time.
• Paid plans (Pro $29/month: 10 requests/s and 100,000 labels/month, Business $99/month: 20 requests/s and 1,000,000 labels/month): subscriptions, monthly or yearly, from the dashboard's Billing page (card, through Stripe), and you can cancel at any time. The workspace's API keys move to the plan's limits as soon as the payment is approved.
• Over a limit the API answers 429 with Retry-After (seconds) and a body that names the limit, e.g. ERROR: Daily limit reached: 20 labels per UTC day on this plan (^PQ copies and PDF pages count).

प्रतिक्रियाएँ और त्रुटियाँ

सफल प्रतिक्रियाएँ X-Total-Count को ले जाती हैं, ज़ेडपीएल द्वारा उत्पन्न लेबल की संख्या, ^PQ प्रतियाँ शामिल हैं। त्रुटियाँ साधारण पाठ होती हैं जो ERROR: से शुरू होती हैं।

इंजन क्या खींचता है, अनदेखा करता है या अभी भी समर्थन नहीं करता है, यह the compatibility page पर है; यह कितनी तेजी से रेंडर करता है, जो उत्पादन सर्वर पर मापा जाता है, the benchmarks page पर।

नियमावली: अपने डेटा के साथ एक सुरक्षित डिज़ाइन भरें

एक लेबल डिज़ाइन करें जिसमें {{variables}} प्लेसहोल्डर्स हों, इसे सहेजें, और अपने डैशबोर्ड से इसका ID कॉपी करें: डिज़ाइन के लिए d123, सहेजे गए लेबल के लिए l45। फिर आपका सिस्टम केवल डेटा भेजता है, एक API कुंजी के साथ।

curl https://api.openzpl.com/v1/templates/d123 \
  -H "X-API-Key: oz_live_…" -H "Accept: application/pdf" \
  -d '{"rows": [{"sku": "A-100"}, {"sku": "A-101"}]}' > labels.pdf

एक लेबल के लिए {"data": {...}} का उपयोग करें या 50 तक के लिए {"rows": [...]} का उपयोग करें। Accept एक PDF या PNG देता है, या text/plain प्रिंटर को भेजने के लिए भरा ZPL। मान सुरक्षित हैं, इसलिए आपका डेटा कभी भी ZPL आदेश शुरू नहीं कर सकता।

स्थानीय प्रिंटर पर प्रिंट करें

जब print agent प्रिंटर के बगल में काम कर रहा है, POST /v1/print-jobs इसके लिए ZPL कतारबद्ध करता है और POST /v1/templates/{id}/print एक सहेजे गए डिज़ाइन को भरता है। दोनों एक printer नाम लेते हैं और एक नौकरी ID लौटाते हैं; GET /v1/print-jobs/{id} आपको बताता है कि यह प्रिंट हुआ या नहीं.

सवाल

API की लागत कितनी है?

बिना कुंजी के आप इसे 3 लेबल प्रति दिन कोशिश कर सकते हैं। एक मुफ्त कुंजी 20 लेबल प्रति दिन की अनुमति देती है, और paid plans 100,000 लेबल के लिए $29 प्रति माह से शुरू होती है।

क्या यह Labelary के साथ संगत है?

हाँ: वही पथ, हेडर और त्रुटियाँ। होस्टनेम बदलें और अपनी कुंजी भेजें, जैसे कि migration guide दिखाता है।

क्या आप मेरे लेबल रखते हैं?

API कुंजी के बिना: लेबल को रेंडर किया जाता है और वापस किया जाता है। privacy page में विवरण और समय सीमा होती है।

क्या एक AI सहायक इसका उपयोग कर सकता है?

हाँ, MCP server के माध्यम से: क्लॉड, कर्सर और अन्य सहायकों के साथ लेबल रेंडर कर सकते हैं।

OpenAPI और Markdown

एक ही अनुबंध OpenAPI 3.1 और Markdown के रूप में प्रकाशित होता है, कोड जनरेटर्स और कोडिंग सहायक के लिए।

चरण-दर-चरण गाइड: Python, Node.js, PHP, C#। Labelary से माइग्रेट करना: migration guide।