Skip to content
HIPS
  • Earn with your GPU
  • Pricing
  • Docs
Sign inJoin early access
⌘K

Get started

  1. 01Developer hub
  2. 02Quickstart
  3. 03Migrate to HIPS

Guides

  1. 04HIPS SDK
  2. 05Import and run your model
  3. 06Model and task guides
    1. ATask guides
    2. BLanguage (chat)
    3. CClassification
    4. DImage
    5. EVideo
    6. FAudio
    7. GDocument processing
  4. 07Batch jobs
  5. 08Prompt caching
  6. 09Code with HIPS
  7. 10Coding-tool setup
    1. AHIPS Code
    2. BClaude Code
    3. CCodex
    4. DOpenCode
    5. EKilo
    6. FPi
    7. GQwen Code
    8. HCrush
    9. ICline
    10. JPrime Agent
    11. KAider
    12. LGoose
    13. MHermes Agent
    14. NGrok Build
    15. ODeepSeek Harness
    16. POther coding tools and editor integrations
  8. 11Command line
    1. AInstall and update
    2. BSign in
    3. CStatus and models
    4. DCoding agents
  9. 12Console
    1. AAccount
    2. BWorkspaces
    3. CAPI keys
    4. DSettings
    5. EUsage
    6. FModels
    7. GPlayground
    8. HDeployments
  10. 13Billing
  11. 14Provider setup
    1. AWhen it works
    2. BCommands
    3. CSettings
    4. DProvider Console
    5. EEarnings
    6. FCrash reports
    7. GData centers
  12. 15Semantic routing
  13. 16Guardrails
  14. 17Knowledge

Reference

  1. 18API reference
    1. AAuthentication
    2. BChat completions
    3. CResponses
    4. DMessages
    5. ECount tokens
    6. FModels
    7. GPrices API
    8. HTasks
    9. IEmbeddings and rerank
    10. JImages
    11. KJobs
    12. LUploads
    13. MFiles
    14. NBatches
    15. OWebhooks
    16. PVector stores
    17. QDeployments
    18. RRequirements and headers
    19. SErrors
    20. TUsage
    21. UVersioning
  2. 19Operating guidance
    1. ALimits
    2. BErrors
    3. CRetries and billing outcomes
    4. DIdempotency
    5. EStreaming
    6. FData handling
    7. GCompatibility matrix
  3. 20Changelog
Sheet indexModel and task guides

Get started

  1. 01Developer hub
  2. 02Quickstart
  3. 03Migrate to HIPS

Guides

  1. 04HIPS SDK
  2. 05Import and run your model
  3. 06Model and task guides
    1. ATask guides
    2. BLanguage (chat)
    3. CClassification
    4. DImage
    5. EVideo
    6. FAudio
    7. GDocument processing
  4. 07Batch jobs
  5. 08Prompt caching
  6. 09Code with HIPS
  7. 10Coding-tool setup
    1. AHIPS Code
    2. BClaude Code
    3. CCodex
    4. DOpenCode
    5. EKilo
    6. FPi
    7. GQwen Code
    8. HCrush
    9. ICline
    10. JPrime Agent
    11. KAider
    12. LGoose
    13. MHermes Agent
    14. NGrok Build
    15. ODeepSeek Harness
    16. POther coding tools and editor integrations
  8. 11Command line
    1. AInstall and update
    2. BSign in
    3. CStatus and models
    4. DCoding agents
  9. 12Console
    1. AAccount
    2. BWorkspaces
    3. CAPI keys
    4. DSettings
    5. EUsage
    6. FModels
    7. GPlayground
    8. HDeployments
  10. 13Billing
  11. 14Provider setup
    1. AWhen it works
    2. BCommands
    3. CSettings
    4. DProvider Console
    5. EEarnings
    6. FCrash reports
    7. GData centers
  12. 15Semantic routing
  13. 16Guardrails
  14. 17Knowledge

Reference

  1. 18API reference
    1. AAuthentication
    2. BChat completions
    3. CResponses
    4. DMessages
    5. ECount tokens
    6. FModels
    7. GPrices API
    8. HTasks
    9. IEmbeddings and rerank
    10. JImages
    11. KJobs
    12. LUploads
    13. MFiles
    14. NBatches
    15. OWebhooks
    16. PVector stores
    17. QDeployments
    18. RRequirements and headers
    19. SErrors
    20. TUsage
    21. UVersioning
  2. 19Operating guidance
    1. ALimits
    2. BErrors
    3. CRetries and billing outcomes
    4. DIdempotency
    5. EStreaming
    6. FData handling
    7. GCompatibility matrix
  3. 20Changelog
06
  1. Docs/
  2. Model and task guides/
  3. Image
(Detail D)
llms.txt

Image generation and editing

On this sheet13 sections
  1. Request format
  2. Options
  3. Input images
  4. OpenAI's image routes
  5. Usage unit
  6. Result handling
  7. Content checks
  8. Turning the checks off
  9. The AI-generated mark
  10. Data handling
  11. Retries, limits and refusals
  12. Idempotency
  13. Not available yet

Two tasks. image_generation makes new images from a text prompt. image_edit changes one or more of your images as an instruction says, such as "make the t-shirt green". Both are synchronous: one request, and its answer carries the images inline in base64. Send them on the task API, POST /v1/tasks, or on OpenAI's image routes, POST /v1/images/generations and POST /v1/images/edits, designed to follow OpenAI's image API so its clients work with your HIPS key and base URL (Images). Each image is billed at a fixed price for its size, and every image carries a machine-readable mark that it was made with AI.

F
Fig. 1, sheet 06Model and task guides
TaskInputsWhat it does
image_generationA text prompt; optionally a negative promptNew images from the prompt
image_editOne or more images and an instruction; a mask, on a model that inpaintsYour images changed as the instruction says
  • Task
    image_generation
    Inputs
    A text prompt; optionally a negative prompt
    What it does
    New images from the prompt
  • Task
    image_edit
    Inputs
    One or more images and an instruction; a mask, on a model that inpaints
    What it does
    Your images changed as the instruction says

Note

A route of an image task answers 400 type_not_served at model while no model of its type is served. The image models HIPS serves are listed in GET /v1/models, each with the task it serves, and on Models with the price per image at each size it is offered at.

Request format

On the task API the prompt is the task's one text input, not an option: not empty, at most 64 KiB, with no NUL character. A second text input is a 400 invalid_value. The options below are in options, and the request requirements in the hips object or the x-hips-* headers, as on every task (Tasks).

00000000000000000000000000000000000000001# HIPS_BASE_URL is https://ai.hips.com/v12curl "$HIPS_BASE_URL/tasks" \3  -H "Authorization: Bearer $HIPS_API_KEY" \4  -H "Content-Type: application/json" \5  -d "{\"model\":\"$HIPS_MODEL\",\"task\":\"image_generation\",\"inputs\":[{\"id\":\"p\",\"type\":\"text\",\"text\":\"A red apple on a wooden table, soft morning light\"}],\"options\":{\"width\":1024,\"height\":1024,\"count\":2}}"
Reads from the environmentHIPS_BASE_URLHIPS_API_KEYHIPS_MODEL

An edit adds the image to change as an image input:

Edit request

00000000000000000000000000000000000000001{2  "model": "<catalog id>",3  "task": "image_edit",4  "inputs": [5    {"id": "p", "type": "text", "text": "Make the t-shirt green"},6    {"id": "photo", "type": "image", "data": "<base64 of a PNG, JPEG or WebP>"}7  ],8  "options": {"output_format": "jpeg", "output_quality": 90, "seed": 42}9}
Edit request sample

Options

Parts list: options

  1. 01
    width, heightwhole numbersOptional

    The size in pixels; absent, the model's own size. At least the model's smallest side and at most its largest, never above 8,192; each a multiple of 8 and of the model's own alignment; together at most the model's largest image in pixels, or 4,194,304 (2048 by 2048) where the model states none. The size sets the price (Usage unit). Out of bounds is a 400 invalid_value naming the bound.

  2. 02
    countwhole numberOptional

    The images to make, from 1 to the model's limit and never above 8; 1 when absent.

  3. 03
    stepswhole numberOptional

    Sampling steps, from 1 to the model's limit and never above 200; the model's own when absent. Steps do not change the price: the model's limit bounds the work a price covers.

  4. 04
    seedwhole numberOptional

    From 0 to 9,223,372,036,854,775,807. Absent, HIPS draws one, and the answer's seed says which. The images of a request are made with seed, seed + 1 and so on, as if in one run. A seed is no promise of the same pixels on another GPU.

  5. 05
    negative_promptstringOptional

    What the image should not show. At most 64 KiB, with no NUL character.

  6. 06
    samplerstringOptional

    The model's own when absent. One of euler, euler_a, heun, dpm2, dpm++2s_a, dpm++2m, dpm++2mv2, ipndm, ipndm_v, lcm, ddim_trailing, tcd, res_multistep, res_2s, er_sde, euler_cfg_pp, euler_a_cfg_pp, euler_ge, dpm++2m_sde, dpm++2m_sde_bt, lms.

  7. 07
    schedulerstringOptional

    The model's own when absent. One of discrete, karras, exponential, ays, gits, sgm_uniform, simple, smoothstep, kl_optimal, lcm, bong_tangent, ltx2, logit_normal, flux2, flux, beta, llada_image.

  8. 08
    cfg_scale, guidancenumbersWhere the model takes them

    The classifier-free guidance scale and the distilled guidance, from 0 to 100, the model's own when absent. On a model that does not take the setting, a 400 unsupported_parameter naming it.

  9. 09
    output_formatpng, jpeg, webpOptional

    png when absent. PNG and WebP are lossless; a JPEG is encoded by HIPS from the GPU's lossless image.

  10. 10
    output_qualitywhole numberJPEG only

    A JPEG's quality from 1 to 100, 75 when absent. A PNG or a WebP takes 0 or nothing: any other value is a 400 unsupported_value.

  11. 11
    Any other optionRejected, 400 unknown_parameter

    Never ignored.

Input images

  • Each image is an input with type: "image" and its bytes inline as data, base64 with or without padding. An upload_id is a 400 unsupported_value: image tasks take their images inline.
  • role says what the image is to the edit: reference (the default), an image to change or to take from, or mask, the area to paint over, on a model that inpaints. An edit takes at least one reference image (400 missing_required_parameter), at most one mask (400 invalid_value), and at most the model's number of input images, the mask counted (400 too_many_inputs). A mask sent to a model that takes none is a 400 unsupported_value at the input's role.
  • PNG, JPEG or WebP, told by the image's first bytes, never by a name or a declared type. Each is at most 8,192 pixels on a side and 33,554,432 pixels, read from its header before anything decodes it; anything else is a 400 invalid_image naming the input.
  • All the images of one request together are at most 3,096,576 bytes, since they travel to the GPU in one message; more is a 400 input_too_large. Send smaller or fewer images.
  • Their metadata is removed before an image reaches a GPU or the content checks: EXIF (a GPS position, a camera's serial number, an owner's name), XMP, color profiles, comments, thumbnails and text. No pixel is changed.

OpenAI's image routes

POST /v1/images/generations takes OpenAI's JSON body and POST /v1/images/edits its multipart form, designed to follow OpenAI's image API with the HIPS key and base URL; the compatibility matrix records each client once it is tested. Each is served as the task it stands for, with every rule on this page. They take model, prompt, n, size (<width>x<height>, or auto for the model's own), output_format and output_compression, a jpeg output's quality from 1 to 100; the edit route the images as image or image[] files and a mask file. They take no seed, steps, negative prompt or sampler: use the task API for those. Every field HIPS does not serve is refused with a 400 naming it, never ignored (Images).

00000000000000000000000000000000000000001import base642import os3 4from openai import OpenAI5 6client = OpenAI(7    api_key=os.environ["HIPS_API_KEY"],8    base_url=os.environ["HIPS_BASE_URL"],  # https://ai.hips.com/v19)10 11made = client.images.generate(12    model=os.environ["HIPS_MODEL"],13    prompt="A red apple on a wooden table, soft morning light",14    size="1024x1024",15)16with open("apple.png", "wb") as f:17    f.write(base64.b64decode(made.data[0].b64_json))18 19edited = client.images.edit(20    model=os.environ["HIPS_MODEL"],21    image=open("photo.png", "rb"),22    prompt="Make the t-shirt green",23)24with open("photo-green.png", "wb") as f:25    f.write(base64.b64decode(edited.data[0].b64_json))
Reads from the environmentHIPS_API_KEYHIPS_BASE_URLHIPS_MODEL

Usage unit

  • image: a fixed price per output image at each size the model is offered at, the same in both pools. Steps, the seed and the model's settings do not change it.
  • The quote is bound when the request is accepted: the images asked times the price at their size. That maximum is held against your balance first, a 402 insufficient_credit when it does not cover it, and a budget guardrail counts it like any request.
  • The bill is the images delivered times that price, in x-hips-cost-micros. An image the content checks withhold is not billed, and a request that delivers no image is billed nothing.
  • An image request is billed for the images that were made, even if the client left before reading them, and if the client left before the output check finished, that includes any images the check would have withheld; a retry with the same idempotency key is then refused (result_expired, naming the first request), never run or billed again; a request the client leaves before any image is made is not charged.
  • A size the model allows and no price covers is a 400 invalid_value whose message names the sizes the model is offered at (options.width on the task API, size on OpenAI's routes).
  • On the task API, usage.units counts the images asked and usage.billed_units the images billed. OpenAI's routes answer no usage.

Result handling

The task API answers one entry in results per image asked, in order, each with input the prompt's id and its index: the image's media_type, width, height and data in base64, or the error of an image the content checks withheld. The answer's seed is the one the images were made with.

Answer

00000000000000000000000000000000000000001{2  "object": "task",3  "id": "job_...",4  "model": "<pinned id>",5  "task": "image_generation",6  "results": [7    {"input": "p", "index": 0, "media_type": "image/png", "width": 1024, "height": 1024, "data": "<base64>"},8    {"input": "p", "index": 1, "error": {"message": "HIPS's automated content checks withheld this image: ...", "type": "invalid_request_error", "param": null, "code": "image_withheld"}}9  ],10  "seed": 1234567,11  "usage": {"units": 2, "unit": "image", "billed_units": 1}12}
Answer sample

OpenAI's routes answer created, data with each delivered image's b64_json in order, output_format and size. A withheld image is left out of data, and the answer gains a hips object whose withheld names its index among the images asked, with its error:

Answer on OpenAI's routes

00000000000000000000000000000000000000001{2  "created": 1792663200,3  "data": [{"b64_json": "<base64>"}],4  "output_format": "png",5  "size": "1024x1024",6  "hips": {7    "withheld": [8      {"index": 1, "error": {"message": "HIPS's automated content checks withheld this image: ...", "type": "invalid_request_error", "param": null, "code": "image_withheld"}}9    ]10  }11}
Answer on OpenAI's routes sample
  • Images are answered inline alone. HIPS keeps no image after its answer, so there is no URL to fetch one from later: save what you need from the answer.
  • Every image is 8-bit RGB, with no transparency, and carries the AI-generated mark below and no other metadata.
  • A request whose images are made on more than one GPU, which HIPS does when one GPU's answer cannot carry them all, delivers all of them or none: if one part fails, nothing is delivered and nothing is billed.

Content checks

While the checks are on, as they are by default, every image request is checked twice. Its prompt, with an edit's input images, is checked before any GPU works on it, and every image made is checked before it reaches you. The checks look for the content the Acceptable Use Policy prohibits in Sections 5.2 to 5.4: sexual content involving a minor, intimate imagery of an identifiable real person made or changed without their consent, and sexually explicit content. A decision service outside HIPS judges each check. The checks add nothing to the bill.

WhenWhat you getBilled
The prompt or an input image is refused400 content_refused before any GPU works on it: at the prompt, inputs[0].text (prompt on OpenAI's routes), for a generation; at inputs (image on the edit route) for an edit, whose prompt and images are judged togetherNothing
An image made is withheldThe other images, and the withheld one's image_withheld error in its results entry, or in hips.withheld on OpenAI's routesThe images delivered
Every image made is withheld400 content_refused at taskNothing
The check cannot run (the decision service failed or did not answer in time)503 content_check_unavailable with Retry-After: HIPS sends no image request uncheckedNothing
The day's content checks are used up, HIPS's whole day's or the workspace's share of it429 rate_limit_exceeded with param checks, and Retry-After until they renew at midnight UTCNothing
The request requires a region400 requirement_conflict before any work, while the checks are on: the decision service is outside every region's processing, and a request that requires a region is processed only in its regionNothing
  • When
    The prompt or an input image is refused
    What you get
    400 content_refused before any GPU works on it: at the prompt, inputs[0].text (prompt on OpenAI's routes), for a generation; at inputs (image on the edit route) for an edit, whose prompt and images are judged together
    Billed
    Nothing
  • When
    An image made is withheld
    What you get
    The other images, and the withheld one's image_withheld error in its results entry, or in hips.withheld on OpenAI's routes
    Billed
    The images delivered
  • When
    Every image made is withheld
    What you get
    400 content_refused at task
    Billed
    Nothing
  • When
    The check cannot run (the decision service failed or did not answer in time)
    What you get
    503 content_check_unavailable with Retry-After: HIPS sends no image request unchecked
    Billed
    Nothing
  • When
    The day's content checks are used up, HIPS's whole day's or the workspace's share of it
    What you get
    429 rate_limit_exceeded with param checks, and Retry-After until they renew at midnight UTC
    Billed
    Nothing
  • When
    The request requires a region
    What you get
    400 requirement_conflict before any work, while the checks are on: the decision service is outside every region's processing, and a request that requires a region is processed only in its region
    Billed
    Nothing

The message of a refusal and of a withheld image is the statement of reasons the Acceptable Use Policy gives in Section 13.5. A withheld image's reads: "HIPS's automated content checks withheld this image: it appears to show content the Acceptable Use Policy prohibits (Sections 5.2 to 5.4 and 11.10). This message is the statement of reasons (Section 13.5). It was not charged." HIPS records each refusal against the workspace with its reason, never the prompt or an image, to enforce the policy.

Turning the checks off

The checks are on by default. An owner or admin can turn them off for the workspace's image requests in Workspace settings. A model whose license requires content filtering or a review of its outputs keeps its checks on whatever the workspace sets, and the setting names those models beside the switch. Whatever any setting says, every image carries the mark below.

The AI-generated mark

Every image HIPS answers carries a machine-readable mark that it was made with AI: the IPTC digital source type trainedAlgorithmicMedia for a generated image and compositeWithTrainedAlgorithmicMedia for an edit, as Iptc4xmpExt:DigitalSourceType in an XMP packet. A PNG carries it in an iTXt chunk named XML:com.adobe.xmp, a JPEG in an APP1 segment and a WebP in an XMP chunk. Writing it changes no pixel. The image carries no other metadata: not the prompt, the seed or the settings.

The Acceptable Use Policy (Section 6.3) asks you not to remove, alter or obscure it, and not to present an image as made by a person where the law requires its artificial origin to be disclosed.

Data handling

  • "HIPS never trains on, retains or logs your prompt data." A prompt and its images are held in memory for the request alone, on the gateway and on the GPU that serves it, and no image is kept after the answer (Data handling).
  • An input image's metadata is removed before it reaches a GPU or the content checks, and no pixel is changed.
  • The content checks send the prompt and the images to the decision service outside HIPS for the one check, after their metadata is removed.
  • A refusal's record names the workspace and the reason, never the prompt or an image.

Retries, limits and refusals

  • An attempt interrupted because its GPU's owner came back, the provider app drained, or the connection or the GPU was lost runs again on another GPU, and you get its answer. An attempt that was canceled is never run again.
  • 503 overloaded with Retry-After when the gateway is at its bound for image requests, or the memory it gives image work is held by others; 503 no_capacity or pool_unavailable when no GPU can serve the model under the request's requirements. Retry after the given delay.
  • An image answer's body must be read within 120 seconds of its head: a client reading slower than about 270 KB/s on a 32 MiB answer is cut, and the answer is not resent.
  • A request the GPUs serving the model cannot make now, such as a size larger than they make, is a 400 naming the field, and nothing is billed. A request that would take more of the gateway's memory than one request may hold is a 400 invalid_value: at options.count (n on OpenAI's routes), naming how many images of that size it can make, or at options.width (size) when one image is too large, with a smaller size or a PNG to ask for, or at inputs when an edit's input images are what does not fit, with smaller input images to send.
  • 500 attempt_failed when every attempt failed, and 500 deadline_exceeded when the request's own time bound ended it. Nothing is billed.
  • Guardrails: budgets and model and pool access apply to image requests as to every request. A content moderation guardrail does not scan a task's text yet, so an image request it applies to is refused 403 guardrail_unsupported, never sent unchecked (Guardrails).

Idempotency

idempotency-key is taken on POST /v1/tasks and on both image routes. HIPS keeps no answer for it: a retry with a key whose first request completed is refused 404 result_expired, its message naming the first request's req_ id, and nothing runs or is billed again. Keep the images from the first answer. The same key while the first request runs is a 400 idempotency_in_progress, and with another body a 400 idempotency_key_reused (Idempotency).

Not available yet

  • POST /v1/jobs: image requests are synchronous, and the job routes are not built yet.
  • Input images by reference, as an upload_id or a URL: images go inline in the request.
  • A URL in the answer (response_format: "url"), streaming and partial images.
  • OpenAI's quality, style, background, moderation and input_fidelity, and output_compression for a lossless output.
  • LoRA adapters, ControlNet, IP-Adapter, upscaling and face detailing, and a model split across several GPUs. Models that take a person's face to keep their identity are not offered.
  • Importing your own image model.

Related sheets

  • Images reference
  • Tasks reference
  • All task guides
Previous sheetClassification
Next sheetVideo
Sheet
06 of 20
Detail
D
Updated
2026-11-16
Sign in to the Console

On this sheet

  1. Request format
  2. Options
  3. Input images
  4. OpenAI's image routes
  5. Usage unit
  6. Result handling
  7. Content checks
  8. Turning the checks off
  9. The AI-generated mark
  10. Data handling
  11. Retries, limits and refusals
  12. Idempotency
  13. Not available yet

Product

  • Inference
  • Models
  • Deploy your model
  • Always-on GPU capacity
  • How it works
  • Use cases
  • Pricing

Developer

  • Docs
  • Quickstart
  • Migrate to HIPS
  • HIPS SDK
  • Batch jobs
  • API reference

Provider

  • Earn with your GPU
  • Register GPU interest
  • Download for Mac
  • Download for Windows
  • Download for Linux

Resource

  • Security and Data
  • Resources
  • llms.txt

Compare

  • OpenRouter alternatives
  • Together AI alternatives
  • Groq alternatives
  • All comparisons

Company

  • About
  • Contact
  • Affiliate program
  • HIPS Payments

Legal

  • Legal
  • Consumer Health Data Privacy Policy
  • Report content
  • Cookie preferences

Support

  • Contact HIPS
  • Looking for payments support?

HIPS. AI inference for builders.

hips.com

Hyperscale Inference Processing Systems OÜ