Using gpt-6-astra for e-commerce product images via the hiapi API

GPT-6 Astra doesn't generate images — here's what it's actually good for in an e-commerce stack

If you came here expecting GPT-6 Astra to paint product photos, it won't — it's a pure text and reasoning model, accessed through the /v1/responses endpoint with no image, audio, or video output at all. But that's not a dead end for e-commerce teams. Every product image lives inside a page that also needs a description, alt text, a support answer, and three ad-channel variants of the same pitch — and that's the layer GPT-6 Astra is actually built for. This guide covers the text side of the product-image workflow: bulk description generation, structured data extraction for listings, and customer Q&A — with real request examples against the Responses API. If you need the photos themselves, pair this with an image model like GPT Image 2 and let GPT-6 Astra handle everything written around them.

Why the Responses API, not Chat Completions

GPT-6 Astra is only exposed through POST /v1/responses — the same endpoint family OpenAI uses for its newer reasoning models — not the older Chat Completions shape. Three differences matter if you're wiring this into a product pipeline:

• input instead of messages. You pass an array of input items, not a messages list. Adapt your Chat Completions client rather than reusing its request builder verbatim.
• stream=true by default in practice, store=false for state. The model streams response.output_text.delta events as text arrives, plus response.output_item.done when a structured item finishes. With store=false, nothing is retained server-side between calls — if you're running a multi-turn support conversation, you replay the prior user/assistant turns yourself in the next input array.
• reasoning.effort instead of temperature. There's no temperature, top_p, or max_output_tokens knob on this integration. You control output quality/latency with reasoning.effort, one of low, medium, high, xhigh, or max (there's no none — reasoning can't be switched off). For short, deterministic jobs like description generation, low or medium is usually enough; save high+ for judgment calls like drafting a policy-sensitive support reply.

Base URL is https://api.hiapi.ai/v1, same key as your other hiapi models.

Use case 1: bulk product description generation with structured output

The most direct e-commerce fit is turning a spec sheet into on-brand listing copy at scale. Instead of parsing free text back out of the model, use text.format.type=json_schema so every response comes back in a shape your CMS can ingest directly — title, short description, long description, and bullet points, all in one call.

import json
import requests

resp = requests.post(
    "https://api.hiapi.ai/v1/responses",
    headers={
        "Authorization": f"Bearer {HIAPI_KEY}",
        "Content-Type": "application/json",
    },
    json={
        "model": "gpt-6-astra",
        "store": False,
        "reasoning": {"effort": "low"},
        "input": [
            {
                "role": "system",
                "content": "You write concise, factual e-commerce listing copy. "
                            "Never invent specs that aren't in the input.",
            },
            {
                "role": "user",
                "content": "Product: ceramic pour-over coffee dripper, 400ml, "
                            "matte white, dishwasher safe, fits standard filters. "
                            "Write listing copy for this product.",
            },
        ],
        "text": {
            "format": {
                "type": "json_schema",
                "name": "listing_copy",
                "schema": {
                    "type": "object",
                    "properties": {
                        "title": {"type": "string"},
                        "short_description": {"type": "string"},
                        "long_description": {"type": "string"},
                        "bullet_points": {
                            "type": "array",
                            "items": {"type": "string"},
                        },
                    },
                    "required": [
                        "title",
                        "short_description",
                        "long_description",
                        "bullet_points",
                    ],
                    "additionalProperties": False,
                },
            }
        },
    },
    stream=False,
)
data = resp.json()

Run this per SKU against your product database and you get consistent, schema-validated copy instead of copy-pasting prose out of a chat window. Keep the system prompt strict about not inventing specs — the model will happily write persuasively about a feature you didn't give it if you let it.

Use case 2: customer support Q&A grounded in your own docs

For a support assistant, the pattern that matters is the store=false replay loop. Each turn, you send the running conversation plus any tool results back in input; the model doesn't remember anything you don't send it. That's a deliberate tradeoff — it costs a bit more in replayed input tokens, but it means your application, not the vendor, owns the conversation state (useful if you need to redact, branch, or resume a conversation from your own database).

history = [
    {"role": "system", "content": "Answer only from the provided product FAQ context. "
                                    "If the answer isn't in context, say so and offer to escalate."},
]

def ask(user_message: str, faq_context: str) -> str:
    history.append({"role": "user", "content": f"Context:\n{faq_context}\n\nQuestion: {user_message}"})
    resp = requests.post(
        "https://api.hiapi.ai/v1/responses",
        headers={"Authorization": f"Bearer {HIAPI_KEY}", "Content-Type": "application/json"},
        json={
            "model": "gpt-6-astra",
            "store": False,
            "reasoning": {"effort": "medium"},
            "input": history,
        },
    )
    answer = resp.json()["output"][-1]["content"][0]["text"]
    history.append({"role": "assistant", "content": answer})
    return answer

For anything that needs to check order status or trigger a return, declare it as a function in tools — the model returns a function_call, your backend executes it, and you send the result back tagged with the same call_id via function_call_output before the model continues. That keeps the model from ever touching your order database directly.

Use case 3: marketing copy variants for different channels

The same product fact set needs different phrasing on a product page, in an email subject line, and in a 30-character ad headline. Because GPT-6 Astra streams response.output_text.delta events, you can generate several channel variants in one pass and render them as they arrive rather than waiting on the full response — useful if this is feeding a live preview in an internal tool. Keep reasoning.effort at low here too; tone-matching short copy doesn't benefit from heavier reasoning, and it keeps latency down when a marketer is iterating live.

What it costs

GPT-6 Astra bills per token, with a hard tier cliff rather than a marginal surcharge — worth knowing before you batch-process a large catalog in one request:

That threshold is checked against total input for the request — including cache reads and writes — and once you cross it, the entire request bills at the long-context rate, not just the tokens past 272,000. For the use cases above (single-product description generation, one support turn, one copy variant), you're nowhere near that line; it mainly matters if you're stuffing an entire product catalog or a long document into one call. Check hiapi.ai/pricing for current rates before committing to a batch job, since these are usage-based and can change.

Where this fits with the rest of your stack

None of this replaces an actual image model — GPT-6 Astra has no /v1/tasks access and can't produce visual output. If your workflow needs the product photography or lifestyle shots to go with this copy, that's a separate call to an image model such as GPT Image 2, and the two don't share request formats or endpoints. Full setup details, including model IDs and the exact request shape, are in the GPT-6 Astra API guide and the model page.

FAQ

Can GPT-6 Astra generate product images? No. It's a text-only model accessed via /v1/responses, with no image, audio, or video output. Pair it with an image model for the visual side of a product listing.

What's the difference between input and the messages array I'd use with Chat Completions? input is the Responses API's request field for conversation turns and content — it isn't a drop-in replacement for messages, so Chat Completions client code needs adapting, not just a field rename.

Do I need to turn reasoning off for simple tasks like description generation? You can't turn it off — there's no reasoning.effort=none. Use low for short, low-stakes generation tasks; it's the fastest and cheapest of the five levels.

Does store=false mean I lose conversation history? No, it means the platform doesn't store it for you. Your application replays the turns it needs in the next input array, which gives you control over what context is included (and lets you redact or branch a conversation) at the cost of paying for those tokens again as input.

Will repeating the same system prompt across many product-description calls get me a cache discount? Not guaranteed. Cache hits depend on server-side policy and timing, not just literal repetition — check cached_tokens in the response's usage object rather than assuming a discount applies.

What happens if I batch an entire product catalog into a single request? If total input tokens (including any cached content) exceed 272,000, the whole request — input, output, and cache usage — bills at the long-context rate, not just the portion over the threshold. For most single-product or single-conversation calls this won't apply, but it's worth checking token counts before batching large catalogs into one call.