Source: https://ailoot.ai/models/pt-pt/recraft-recraft-v4-1-flash/
Canonical: https://ailoot.ai/models/pt-pt/recraft-recraft-v4-1-flash/
Language: pt-pt

# Recraft: Recraft V4.1 Flash

[Markdown](https://ailoot.ai/models/pt-pt/recraft-recraft-v4-1-flash/index.md) · [JSON](https://ailoot.ai/models/pt-pt/recraft-recraft-v4-1-flash/facts.json)

## [Recraft: Recraft V4.1 Flash](https://ailoot.ai/models/pt-pt/recraft-recraft-v4-1-flash/)

O Recraft V4.1 Flash gera imagens raster 1K a partir de texto para iteração visual rápida. Suporta fotografia, retratos, cenas complexas e conceitos de logótipos, com saída PNG ou WebP sem perdas e preferências de cor explícitas.

- [**Ailoot Ultra · Imagens** `POST /v1/images/generations` `recraft/recraft-v4.1-flash`](https://ailoot.ai/models/pt-pt/recraft-recraft-v4-1-flash/#method-0)

Sobre o modelo

Esta descrição apresenta as capacidades do modelo. As entradas, saídas e opções disponíveis no Ailoot para o método selecionado estão indicadas abaixo.

O Recraft V4.1 Flash é o modelo de texto para imagem da Recraft para iteração rápida e trabalho visual em grande volume. O fabricante identifica a fotografia, os retratos, a atmosfera, as cenas complexas, as técnicas mistas e os conceitos de logótipos como utilizações fortes. Um briefing escrito transforma-se numa imagem raster que pode ser comparada com outras direções criativas antes de desenvolver a peça final. O Flash é um membro específico da família V4.1, com o seu próprio tamanho de saída e controlos suportados.

A saída nativa pertence à classe de imagens raster 1K da Recraft. Escolha a tela em função do posicionamento previsto: uma ilustração horizontal para o cabeçalho de uma página, um retrato vertical ou uma imagem quadrada para um cartão compacto. Os formatos de saída são WebP sem perdas e PNG.

Comece o briefing pelo tema principal e pela finalidade visual e descreva depois o enquadramento, o cenário, a iluminação e o meio. Para um conceito de produto, uma instrução útil é: «Um rádio compacto de cor creme sobre uma secretária de nogueira, vista frontal a três quartos, luz suave de janela, fotografia editorial tranquila, amplo espaço vazio à esquerda.» Para uma ilustração, identifique a linguagem das formas, a paleta e a relação entre os elementos. Mantenha explícitos os pormenores que definem a ideia, em vez de acrescentar adjetivos sem relação entre si. O limite documentado de instruções do Flash é de até 10 000 caracteres, permitindo descrever uma cena detalhada quando a tarefa o exige.

Os controlos do fabricante incluem cores preferidas e uma cor de fundo desejada. Pode fornecer uma semente para resultados reproduzíveis e a interface de geração documenta uma a seis imagens por pedido. Estes controlos permitem uma comparação útil: mantenha o tema e a composição estáveis, varie uma direção visual e avalie as imagens resultantes na composição pretendida. As preferências de cor descrevem o resultado solicitado; compare as cores importantes da marca com a peça terminada antes de a integrar num sistema de design existente.

O Flash produz gráficos raster. Um conceito de logótipo pode ajudar a escolher uma silhueta, um ambiente ou uma disposição, enquanto os caminhos editáveis pertencem aos modelos Vector identificados separadamente. O Flash também não tem uma variante Pro. A linha V4.1 completa oferece essas escolhas separadas quando a edição vetorial ou os pormenores de maior resolução são centrais para a entrega. O fabricante descreve uma etapa posterior de aperfeiçoamento para levar um esboço escolhido a uma imagem mais detalhada; essa etapa é uma operação distinta, e não um tamanho nativo de saída Flash diferente.

Esta edição não suporta entrada de imagem para imagem, estilos personalizados, identificadores de estilo, correspondência de estilos nem imagens de referência de estilo. A sua interface documentada também exclui instruções negativas e controlos explícitos de disposição de texto. Inclua a aparência e a composição solicitadas no briefing positivo. Quando um conceito incluir letras, coloque entre aspas o texto pretendido e examine as letras renderizadas; utilize uma etapa separada de composição quando a tipografia e o posicionamento exatos forem essenciais.

Um resultado prático do Flash é uma direção visual selecionada com um briefing claro, uma proporção adequada e um ficheiro raster utilizável. Compare o tema, o enquadramento, o fundo e os pormenores importantes no tamanho em que a imagem será apresentada. Guarde a instrução bem-sucedida juntamente com o ficheiro escolhido, para que a próxima etapa criativa siga a direção selecionada. A iteração rápida ajuda a explorar o design; a saída vetorial nativa, a correspondência com referências de estilo e a resolução de outra edição V4.1 continuam a ser escolhas de modelo separadas.

**Ailoot Ultra · Imagens** `POST /v1/images/generations` `recraft/recraft-v4.1-flash`

[`recraft/recraft-v4.1-flash`](https://ailoot.ai/models/pt-pt/#m=recraft%2Frecraft-v4.1-flash&route=Ultra&caller=recraft%2Frecraft-v4.1-flash&fmt=images)

Recraft /`recraft/recraft-v4.1-flash`

### Introdução

O Recraft V4.1 Flash gera imagens raster 1K a partir de texto para iteração visual rápida. Suporta fotografia, retratos, cenas complexas e conceitos de logótipos, com saída PNG ou WebP sem perdas e preferências de cor explícitas.

Entradas aceites

Texto

Resultados

Imagens

### Disponível no Ailoot · entradas e métodos

**Ailoot Ultra · Imagens** `POST /v1/images/generations`

Entrada

`text`

Saída

`image`

Formato de saída

Ficheiro de imagem

Número de saídas

1 saída

| Campo | Tipo | Requisito | Valores e limites | Predefinição |
| --- | --- | --- | --- | --- |
| Campo`model` | Tipo`string` | RequisitoObrigatório | Valores e limites recraft/recraft-v4.1-flash | Predefinição— |
| Campo`prompt` | Tipo`string` | RequisitoObrigatório | Valores e limites Comprimento mínimo: 1 Condições: Instrução UTF8 não vazia. Não se inventa um limite de carateres comum a todo o fabricante. | Predefinição— |
| Campo`n` | Tipo`integer` | RequisitoOpcional | Valores e limites 1 | Predefinição1 |
| Campo`response_format` | Tipo`string` | RequisitoOpcional | Valores e limites url, b64\_json | Predefinição— |
| Campo`stream` | Tipo`boolean` | RequisitoOpcional | Valores e limites false | Predefiniçãofalse |

Combinações de materiais de entrada

**Texto para imagem** · Obrigatório: prompt

Parâmetros e ciclo de vida do método

| Parâmetro | Contrato |
| --- | --- |
| Parâmetro`content_type` | Contratoapplication/json |
| Parâmetro`required` | Contratomodel, prompt |
| Parâmetro`material_types` | Contratotext |
| Parâmetro`optional` | Contraton, response\_format, stream |
| Parâmetro`n` | Contrato1 |
| Parâmetro`stream` | Contratofalse |
| Parâmetro`response_format` | Contratourl, b64\_json |
| Parâmetro`reference_images` | Contratofalse |
| Parâmetro`edit` | Contratofalse |
| Parâmetro`output_format_optional` | Contrato |
| Parâmetro`resolution_control` | Contratonull |
| Parâmetro`aspect_ratio_control` | Contratonull |
| Parâmetro`other_fields` | Contratorejeitado, exceto para o encaminhamento interno exato e fixado do fornecedor |

Ciclo de vida: `synchronous_result_then_owned_library`

`GET /v1/media/tasks/{task_id}` · task\_id efetivamente devolvido ou registo na biblioteca de multimédia

`GET /v1/media/assets/{asset_id}/content`

`GET /v1/media/assets`

`GET /v1/media/assets/{asset_id}`

Gere uma imagem a partir de uma instrução.

Guarde todos os elementos de dados; url/b64\_json são codificações dos resultados.

### Tarifários

##### Cálculo do custo final

As tarifas apresentadas permitem estimar o custo antes da geração. O montante final cobrado é calculado a partir do custo registado para a geração original. A duração medida do resultado e as quantidades previstas não correspondem à quantidade final faturável.

As referências tarifárias não acrescentam opções ao pedido. Os parâmetros suportados constam do método selecionado.

Modo rápido

Não especificado Quando o modo rápido está selecionado

Modo flex

Não especificado Quando o modo flex está selecionado

Esforço máximo de raciocínio

Não especificado Quando o esforço máximo de raciocínio usa o ajuste predefinido (default)

#### Tarifas estimadas para comparação

#### Preços por configuração

Associe cada custo às condições apresentadas. Use uma única tarifa para cada conjunto de configurações alternativas.

| Configuração | Tabela de tarifas | Quantidade prevista | Unidade de faturação | Custo |
| --- | --- | --- | --- | --- |
| ConfiguraçãoTarifas base por token | Tabela de tarifasTarifa base | Quantidade prevista— | Unidade de faturação— | Custo Entrada · Tokens de entrada · Estimativa apenas para comparação **—** / 1K tokens Saída · Tokens de saída · Estimativa apenas para comparação **—** / 1K tokens Entrada · Leitura da cache · Estimativa apenas para comparação **—** / 1K tokens Entrada · Escrita na cache · Estimativa apenas para comparação **—** / 1K tokens Entrada · Escrita na cache, 1 hora · Estimativa apenas para comparação **—** / 1K tokens |
| ConfiguraçãoUltra | Tabela de tarifas— | Quantidade prevista— | Unidade de faturaçãopor imagem de saída | Custo Saída · imagem de saída · Estimativa apenas para comparação **$0.014** por imagem de saída |
| ConfiguraçãoCusto estimado de geração | Tabela de tarifas— | Quantidade previstaestimativa para uma geração | Unidade de faturação— | Custo Saída · Custo estimado de geração · Estimativa apenas para comparação **$0.014** estimativa antes da geração Esta estimativa não é um encargo adicional nem uma tarifa fixa para a geração concluída. |

O Ailoot reserva um montante estimado antes de um pedido. Após o resultado, liquida o custo final com base na utilização medida. No streaming, a liquidação usa o registo final de utilização. [Como funcionam a reserva e a liquidação →](https://ailoot.ai/docs/pt-pt/billing/reserve/)

#### Detalhes da tarifa de referência

As tabelas de referência do modelo não alteram a seleção do método, as cotações ou os custos. Os custos ativos usam as tarifas do método Ailoot selecionado.

Configurações de preços de imagens

#### Preços por configuração

| Configuração | Condições de faturação | Custo |
| --- | --- | --- |
| ConfiguraçãoImagem de saída | Condições de faturaçãoNão está declarada qualquer variante de preços. | Custo Saída · Imagem de saída **$0.014** por imagem As entradas equivalentes descrevem a mesma cobrança; não acrescentam uma segunda taxa. |

### Exemplos de pedidos

#### Ailoot Ultra · Imagens

curlPython SDKNode.js SDK

```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
export AILOOT_API_KEY
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "recraft/recraft-v4.1-flash", "prompt": "A lighthouse on a cliff, watercolor", "n": 1, "response_format": "b64_json"}')

Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/images/generations \
  -H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \
  --data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import base64, json, os, subprocess
from pathlib import Path
from urllib.parse import urlsplit, urljoin

def save_images(items):
    if not items: raise SystemExit("No completed images; retain the full response")
    for index, item in enumerate(items):
        encoded=item.get("b64_json")
        uri=item.get("url", "")
        if not encoded and uri.startswith("data:image/"):
            header, separator, encoded=uri.partition(",")
            if not separator or ";base64" not in header: raise SystemExit("Unsupported image data URI")
        if encoded:
            raw=base64.b64decode(encoded,validate=True)
        elif uri:
            uri=urljoin("https://api.ailoot.ai",uri)
            parsed=urlsplit(uri)
            if parsed.scheme!="https" or not parsed.netloc or parsed.username or parsed.password:
                raise SystemExit("Invalid returned image URL")
            owned=parsed.netloc=="api.ailoot.ai" and parsed.path.startswith("/v1/media/assets/") and parsed.path.endswith("/content")
            args=["curl","--fail-with-body","--silent","--show-error",uri]
            if owned: args += ["-H","Authorization: Bearer "+os.environ["AILOOT_API_KEY"]]
            temporary=Path(f"image-{index}.bin")
            subprocess.run(args+["-o",str(temporary)],check=True)
            raw=temporary.read_bytes()
            temporary.unlink()
        else: raise SystemExit("Image has neither bytes nor URL")
        if not raw: raise SystemExit("Empty image result")
        ext="png" if raw.startswith(b"\x89PNG") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4]==b"RIFF" and raw[8:12]==b"WEBP" else "svg" if raw.lstrip().startswith((b"<svg",b"<?xml")) else "bin"
        Path(f"image-{index}.{ext}").write_bytes(raw)
    print("Every returned image saved; complete response metadata retained")
save_images(json.loads(Path("result.json").read_text())["data"])
PY_RESULT
```

```python
from openai import OpenAI
import base64, json, os, subprocess
from pathlib import Path
from urllib.parse import urlsplit, urljoin

def save_images(items):
    if not items: raise SystemExit("No completed images; retain the full response")
    for index, item in enumerate(items):
        encoded=item.get("b64_json")
        uri=item.get("url", "")
        if not encoded and uri.startswith("data:image/"):
            header, separator, encoded=uri.partition(",")
            if not separator or ";base64" not in header: raise SystemExit("Unsupported image data URI")
        if encoded:
            raw=base64.b64decode(encoded,validate=True)
        elif uri:
            uri=urljoin("https://api.ailoot.ai",uri)
            parsed=urlsplit(uri)
            if parsed.scheme!="https" or not parsed.netloc or parsed.username or parsed.password:
                raise SystemExit("Invalid returned image URL")
            owned=parsed.netloc=="api.ailoot.ai" and parsed.path.startswith("/v1/media/assets/") and parsed.path.endswith("/content")
            args=["curl","--fail-with-body","--silent","--show-error",uri]
            if owned: args += ["-H","Authorization: Bearer "+os.environ["AILOOT_API_KEY"]]
            temporary=Path(f"image-{index}.bin")
            subprocess.run(args+["-o",str(temporary)],check=True)
            raw=temporary.read_bytes()
            temporary.unlink()
        else: raise SystemExit("Image has neither bytes nor URL")
        if not raw: raise SystemExit("Empty image result")
        ext="png" if raw.startswith(b"\x89PNG") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4]==b"RIFF" and raw[8:12]==b"WEBP" else "svg" if raw.lstrip().startswith((b"<svg",b"<?xml")) else "bin"
        Path(f"image-{index}.{ext}").write_bytes(raw)
    print("Every returned image saved; complete response metadata retained")

request={'model': 'recraft/recraft-v4.1-flash', 'prompt': 'A lighthouse on a cliff, watercolor', 'n': 1, 'response_format': 'b64_json'}
client=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)
result=client.images.generate(**request)
Path("sdk-result.txt").write_text(str(result),encoding="utf-8")
save_images([{"b64_json":getattr(item,"b64_json",None),"url":getattr(item,"url",None)} for item in result.data])
```

```js
import OpenAI from "openai";
import { readFileSync, writeFileSync } from "node:fs";
const key=process.env.AILOOT_API_KEY;
if(!key) throw new Error("Set your actual Ailoot API key");
const client=new OpenAI({baseURL:"https://api.ailoot.ai/v1",apiKey:key,maxRetries:0});
const request={"model": "recraft/recraft-v4.1-flash", "prompt": "A lighthouse on a cliff, watercolor", "n": 1, "response_format": "b64_json"};
const result=await client.images.generate(request);
writeFileSync("sdk-result.json",JSON.stringify(result,null,2));
if(!result.data?.length) throw new Error("No completed images");
for(let index=0;index<result.data.length;index++) {
  const item=result.data[index];let encoded=item.b64_json,uri=item.url||"",raw;
  if(!encoded && uri.startsWith("data:image/")) {
    const comma=uri.indexOf(",");if(comma<0 || !uri.slice(0,comma).includes(";base64")) throw new Error("Unsupported image data URI");
    encoded=uri.slice(comma+1);
  }
  if(encoded) {
    if(encoded.length%4!==0 || !/^[A-Za-z0-9+/]*={0,2}$/.test(encoded)) throw new Error("Invalid Base64");
    raw=Buffer.from(encoded,"base64");
  } else if(uri) {
    const u=new URL(uri,"https://api.ailoot.ai");
    if(u.protocol!=="https:" || u.username || u.password) throw new Error("Invalid returned URL");
    const owned=u.origin==="https://api.ailoot.ai" && u.pathname.startsWith("/v1/media/assets/") && u.pathname.endsWith("/content");
    const response=await fetch(u,{headers:owned?{Authorization:"Bearer "+key}:{},redirect:"manual"});
    if(!response.ok) throw new Error("Image content download failed: "+response.status);
    raw=Buffer.from(await response.arrayBuffer());
  } else throw new Error("Image has neither bytes nor URL");
  if(!raw.length) throw new Error("Empty image result");
  const ext=raw.subarray(0,4).equals(Buffer.from([137,80,78,71]))?"png":raw[0]===255&&raw[1]===216?"jpg":raw.toString("ascii",0,4)==="RIFF"&&raw.toString("ascii",8,12)==="WEBP"?"webp":raw.toString("utf8").trimStart().startsWith("<svg")||raw.toString("utf8").trimStart().startsWith("<?xml")?"svg":"bin";
  writeFileSync(`image-${index}.${ext}`,raw);
}
console.log("Every returned image saved; sdk-result.json retains complete metadata");
```

### Receber e guardar os resultados

#### Ailoot Ultra · Imagens

Descarregue cada imagem devolvida ou guarde o respetivo conteúdo Base64

- `GET /v1/media/tasks/{task_id}`
- `GET /v1/media/assets/{asset_id}/content`
- `GET /v1/media/assets`
- `GET /v1/media/assets/{asset_id}`

##### Guardar todos os resultados concluídos

Guarde cada imagem concluída; obtenha cada URL devolvido ou descodifique o respetivo conteúdo Base64.

Guarde todos os itens de dados. Descodifique cada b64\_json ou obtenha todos os URL assinados devolvidos. Escolha a extensão do ficheiro a partir do MIME/dos bytes reais.

##### Se for necessário verificar a resposta original

Se o resultado de uma geração ou edição de imagem requerer verificação, guarde o operation\_id/X-Client-Request-ID original e as informações do resultado devolvidas. Recupere os resultados existentes que lhe pertencem através da biblioteca de multimédia, usando valores task\_id ou asset\_id reais. Não volte a enviar o pedido de geração/edição nem construa um URL de consulta periódica a partir de operation\_id.

Campos da resposta

| Campo | Tipo |
| --- | --- |
| Campo`created` | Tipointeger |
| Campo`data[].url` | Tipostring |
| Campo`data[].b64_json` | Tipobase64 string |
| Campo`usage` | Tipoobject |

Erros e passos seguintes

| Resposta | Condição | Passo seguinte |
| --- | --- | --- |
| Resposta400 · `invalid_request_error` | CondiçãoCampos obrigatórios, representação do material ou valor do parâmetro inválidos | Passo seguinteCorrija os campos indicados antes de um novo pedido de criação. |
| Resposta`server_error` | CondiçãoA resposta devolvida indica que a operação ou o resultado requer verificação | Passo seguinteGuarde o ID original da operação/tarefa devolvido, os cabeçalhos do pedido e a resposta; continue a consultar essa operação original através das consultas suportadas. Não volte a enviar o pedido de criação. |

### Aliases

#### Aliases do modelo

**Ailoot Ultra** [`recraft/recraft-v4.1-flash`](https://ailoot.ai/models/pt-pt/#m=recraft%2Frecraft-v4.1-flash&route=Ultra&caller=recraft%2Frecraft-v4.1-flash&fmt=images)

#### Aliases dos caminhos dos métodos

Use os caminhos dos métodos indicados acima.

#### IDs de chamada relacionados

[`recraft/recraft-v4.1-flash`](https://ailoot.ai/models/pt-pt/#m=recraft%2Frecraft-v4.1-flash&route=Ultra&caller=recraft%2Frecraft-v4.1-flash&fmt=images)

FAQ · Recraft: Recraft V4.1 Flash

Que entradas e resultados estão disponíveis?

`POST /v1/images/generations` · `recraft/recraft-v4.1-flash`: `text` → `image`

Que campos utiliza o pedido?

`POST /v1/images/generations` · `recraft/recraft-v4.1-flash`: `model`, `prompt`, `n`, `response_format`, `stream`

Ligue o Ailoot ao Claude Code, OpenCode, Hermes ou à sua aplicação.

## A empresa e a sua carteira de projetos

A empresa e a sua carteira de projetos: milhões de clientes; vendas mensais na ordem dos milhares de milhões.

## Compre tokens com desconto.

Desconto por subscrição para trabalho regular. Códigos promocionais — até 50% na compra de tokens.

Subscrição

Escolha um plano com desconto para os pedidos regulares.

Código promocional até 50%

Introduza o código na compra. O preço é recalculado conforme a campanha em vigor.

Custos no histórico

O modelo, os tokens e o montante são guardados para cada pedido.

[Escolher subscrição](https://ailoot.ai/docs/pt-pt/billing/subscriptions/) · [Ver preços dos modelos](https://ailoot.ai/models/pt-pt/)

## Ligue a API ao produto que vende.

SaaS, aplicações e bots — ao abrigo da oferta e do contrato de licença Ailoot. Para revenda, peça uma licença de revendedor.

Aplicação comercial

Integre geração de texto, imagens, vídeo e som nas funcionalidades pagas do seu serviço.

Licença de revendedor

Envie uma descrição do projeto e do modelo de acesso. Peça condições escritas de utilização e revenda.

Documentos no site

A oferta, o contrato de licença e a política de tratamento de dados estão disponíveis antes da ligação.

[Pedir licença de revendedor](mailto:support@ailoot.ai) · [Oferta e contrato de licença](https://ailoot.ai/legal/offer?lang=pt-pt)

## Ailoot · A empresa e a sua carteira de projetos





A Ailoot assenta numa experiência operacional consolidada, numa ampla base de clientes, num serviço estável e no acompanhamento contínuo dos KPI.





A empresa e a sua carteira de projetos: milhões de clientes; vendas mensais na ordem dos milhares de milhões.





A Ailoot aplica essa experiência operacional ao acesso por API a funcionalidades de IA nos produtos dos clientes, agentes, aplicações e automatizações.