JANCTION Render

Renderize cenas do Blender em GPUs na nuvem a partir de agentes de IA (Claude, ChatGPT, Codex, Cursor). Envie um .blend, um script bpy ou um arquivo glTF/FBX/USD e receba uma prévia de 4 quadros, uma estimativa de tempo e, em seguida, os quadros finais ou um MP4. MCP remoto com OAuth ou stdio via pip. Grátis até 500 JPY de tempo de GPU por nova chave, depois 0,1 JPY por segundo de GPU.

GitHub

Servidor MCP hospedado

npx add-mcp 'https://render.janction.jp/mcp'

Instala no Claude Code, Codex, Cursor e outros

Documentação

JANCTION Render

O que é o JANCTION Render?

O JANCTION Render é um farm de renderização GPU em nuvem para Blender que agentes de IA utilizam como servidor MCP ou API HTTP. Envie um arquivo .blend, um script bpy ou um arquivo 3D (glTF / FBX / USD), visualize em segundos e receba frames ou um MP4 das GPUs NVIDIA da JANCTION. Cada preview também retorna um veredito sobre o que está errado, como muito escuro, estourado, sem luz ou um objeto fora do quadro, e o código bpy para corrigir, para que o agente possa ajustar a cena antes da renderização final. Não é necessário Blender local ou GPU. Um crédito de boas-vindas de 100 JPY para uma nova chave (um por rede a cada 30 dias; chaves adicionais na mesma rede compartilham o saldo restante) e mais 400 JPY ao salvar um cartão que não é cobrado (uma vez por cartão), depois 0,1 JPY por segundo de GPU (previews gratuitos até 2 minutos de GPU por dia); operado pela JasmyLab Inc.

Agentes de IA podem renderizar projetos Blender nas GPUs da JANCTION sem executar o Blender localmente. Funciona com Claude, ChatGPT, Claude Code, Codex, Cursor ou qualquer cliente MCP: um servidor MCP (remoto e stdio), uma API HTTP e uma CLI.

O JANCTION Render é um produto separado do SmartRender (renderização distribuída da JasmyLab para pessoas em desktop) e não é afiliado ao Render.com ou à Render Network. Os números, em 08/10/2026 (a fonte primária é https://render.janction.jp/facts.json): um crédito de boas-vindas de 100 JPY (1.000 segundos de GPU, 14 dias, sem cartão) para uma nova chave, um por rede a cada 30 dias (chaves adicionais na mesma rede compartilham o saldo restante), mais 400 JPY adicionais ao salvar um cartão em uma página que não cobra nada (uma vez por cartão); depois disso, previews são gratuitos até 2 minutos de GPU por dia e renderizações finais custam 0,1 JPY por segundo de GPU do crédito pré-pago (uso pago iniciado em 08/10/2026); finais de até 3.000 frames por instrução (executados em partes de 240 sob um único ID de job); 1080p no tempo gratuito, até 4K no crédito pré-pago; entradas e resultados excluídos 24 horas após o último uso (7 dias, normalmente, para chaves que pagaram 500 JPY ou mais no total).

Site oficial: https://render.janction.jp · Endpoint MCP: https://render.janction.jp/mcp · Ficha técnica: https://render.janction.jp/facts

Experimente a partir de um terminal em poucos segundos, gratuitamente e sem necessidade de cadastro (requer uv; ou pip install janction-render e remova o uvx):

uvx janction-render try                      # renders a sample scene and shows the free GPU time of your new key
uvx janction-render preview scene.blend      # your .blend, bpy script or 3D file
uvx janction-render render scene.blend --frames 1-48 --output mp4 --wait
uvx janction-render turntable model.glb      # a 360-degree turntable MP4 in one command (a path or an https link)
uvx janction-render shots model.glb --transparent   # four product shots (PNG)

O que um comando gera (saídas reais)

Renderizado em 10/10/2026 na GPU de produção (NVIDIA RTX PRO 6000 Blackwell) a partir do exemplo WaterBottle da Khronos (domínio público, CC0); copie qualquer linha e ela executa como está. Os preços são de 0,1 JPY por segundo de GPU e são cobertos pelo crédito de boas-vindas de uma nova chave.

Comando	Tempo de GPU	Preço
`uvx janction-render shots https://github.com/KhronosGroup/glTF-Sample-Assets/blob/main/Models/WaterBottle/glTF-Binary/WaterBottle.glb`	13,9 s	cerca de 1,4 JPY
`uvx janction-render turntable https://github.com/KhronosGroup/glTF-Sample-Assets/blob/main/Models/WaterBottle/glTF-Binary/WaterBottle.glb`	85,2 s	cerca de 8,5 JPY
`uvx janction-render render https://render.janction.jp/samples/ex12_logo_ring_spin.py --frames 1-48 --size 1280x720 --engine eevee --output mp4 --wait`	54,1 s	cerca de 5,4 JPY

As capturas são quatro PNGs 1920x1080; o turntable e a animação são MP4s (mostrados aqui como GIFs). Seu próprio .glb, .blend ou script bpy entra no lugar do link. Mais, com seus scripts: https://render.janction.jp/examples

Mantém arquivos 3D em um repositório? Adicione um botão que permite a qualquer pessoa renderizá-los a partir de sua própria IA ou terminal (links para páginas de arquivos no GitHub e Hugging Face funcionam como estão; crie um em https://render.janction.jp/go):

[![Render on JANCTION](https://render.janction.jp/badge.svg)](https://render.janction.jp/go?scene=https://github.com/you/repo/blob/main/model.glb)

Guias no site oficial

Como renderizar Blender sem GPU
De um agente: Claude Code + Blender · Codex + Blender · Cursor + Blender · ChatGPT + Blender · Servidor MCP Blender para renderização
Melhores farms de renderização para agentes de IA (2026): JANCTION, BlendSwap, Sceneplane, seu próprio worker no Modal ou RunPod e um Blender MCP local lado a lado
Blender headless como API · glTF, GLB ou FBX para MP4 · Vídeo de produto 360 graus · Quanto custa uma renderização Blender
Exemplos com seus scripts bpy · Comparar · 日本語のご案内

Por que usar?

Sem GPU, sem instalação do Blender. A cena pode ser um script bpy que o agente escreve, um .blend, ou um arquivo 3D; o Blender roda em nossas GPUs.
Feito para agentes. Preview primeiro (1-4 frames em poucos segundos de GPU), uma estimativa com tempo e custo antes da final, erros estruturados com a correção, limites de gastos por chave, novas tentativas seguras com Idempotency-Key.
Arquivos 3D e turntables. glTF / GLB, FBX, USD, OBJ, STL, PLY, Alembic são importados em uma cena vazia com câmera e iluminação HDRI; orbit=True cria um turntable. Resultados de preço fixo: POST /v1/outcomes/turntable e /product-shot.
Limites honestos. um crédito de boas-vindas de 100 JPY para uma nova chave sem cartão (14 dias; um por rede a cada 30 dias) e mais 400 JPY após salvar um cartão que não é cobrado, depois 0,1 JPY por segundo de GPU (previews gratuitos até 2 minutos de GPU por dia), finais de até 3.000 frames por instrução em partes de 240 (1080p no tempo gratuito, até 4K no crédito pré-pago), nas próprias GPUs da JANCTION (NVIDIA RTX PRO 6000 Blackwell); quando estão ocupadas, os jobs aguardam em uma fila e o ETA informa isso. Entradas e resultados são excluídos 24 horas após o último uso (7 dias, normalmente, para chaves que pagaram 500 JPY ou mais no total) e nunca usados para treinamento.
Não é Render.com. Mesma palavra, produto diferente.

Início rápido

Claude.ai / ChatGPT (nada para instalar). Configurações → Conectores → adicionar https://render.janction.jp/mcp → Conectar (uma chave gratuita é criada na página de consentimento). Depois cole:

Renderize um preview de https://render.janction.jp/samples/cube_scene.py

Um preview de 4 frames retorna em poucos segundos. Um arquivo no seu computador: solte-o em https://render.janction.jp/upload para obter um link de 12 horas, depois "Renderize este arquivo: ".

Claude Code.

claude mcp add --transport http janction-render https://render.janction.jp/mcp

Depois /mcp para autenticar e pergunte: "Construa uma pequena cena de rua no Blender com um fly-through de câmera e renderize um preview com janction-render."

HTTP (qualquer linguagem).

curl -s -X POST https://render.janction.jp/v1/keys                                   # -> {"api_key": "jr_..."}  no sign-up
curl -s -X POST https://render.janction.jp/v1/files -H "X-API-Key: $KEY" -F "file=@scene.blend"   # -> {"scene_id": "f_..."}
curl -s -X POST https://render.janction.jp/v1/jobs -H "X-API-Key: $KEY" -H "Content-Type: application/json" \
  -d '{"scene_id":"f_...","kind":"preview","frames":[1]}'                             # -> job_id; then GET /v1/jobs/{job_id}

Do seu próprio agente ou aplicativo

Python (pip install janction-render; a primeira chamada cria uma chave gratuita e a mantém em ~/.janction-render.json):

from janction_render.client import Client

c = Client()                                   # or Client(api_key="jr_...")
scene = c.upload("scene.py")                   # a bpy script, a .blend, or a .glb / .fbx / .usd / .obj file
job = c.submit(scene["scene_id"], kind="final", frame_start=1, frame_end=48, output="mp4")
job = c.wait(job["job_id"], timeout=1800)
print(job["status"], c.download(job["job_id"], "out", only="mp4"))

Pague por uso com crédito pré-pago; nenhuma assinatura é necessária (preços: https://render.janction.jp/pricing). Em vez de polling, passe notify_url (https) para POST /v1/jobs e receba um JSON POST quando o job terminar (job.done / job.failed, com links de download); um cabeçalho Idempotency-Key torna as novas tentativas seguras. OpenAPI: https://render.janction.jp/openapi.json Um exemplo de aplicativo completo (um usuário envia um GLB, o aplicativo encomenda fotos de produto de preço fixo, um webhook armazena as imagens): https://render.janction.jp/blender-render-api#embed

Frameworks de agentes conectam-se ao servidor MCP remoto em https://render.janction.jp/mcp com a chave como token bearer (curl -s -X POST https://render.janction.jp/v1/keys fornece uma, sem cadastro).

OpenAI Agents SDK (mantenha o timeout mais longo: render_preview aguarda a imagem, mais longo que o padrão de 5 segundos):

import asyncio
from agents import Agent, Runner
from agents.mcp import MCPServerStreamableHttp

async def main():
    async with MCPServerStreamableHttp(name="janction-render", client_session_timeout_seconds=120,
                                       params={"url": "https://render.janction.jp/mcp",
                                               "headers": {"Authorization": "Bearer jr_..."}}) as render:
        agent = Agent(name="3D artist", instructions="Render Blender scenes with janction-render.", mcp_servers=[render])
        result = await Runner.run(agent, "Render a preview of https://render.janction.jp/samples/cube_scene.py")
        print(result.final_output)

asyncio.run(main())

LangChain (pip install langchain-mcp-adapters):

import asyncio
from langchain_mcp_adapters.client import MultiServerMCPClient

async def main():
    client = MultiServerMCPClient({"janction-render": {"url": "https://render.janction.jp/mcp", "transport": "streamable_http",
                                                       "headers": {"Authorization": "Bearer jr_..."}}})
    tools = await client.get_tools()           # render_preview, render_final, render_status, render_download, ...
    print([t.name for t in tools])

asyncio.run(main())

OpenAI Responses API (MCP remoto; render_final continua pedindo aprovação porque gasta crédito):

from openai import OpenAI

client = OpenAI()
resp = client.responses.create(
    model="gpt-5",
    tools=[{"type": "mcp", "server_label": "janction_render", "server_url": "https://render.janction.jp/mcp",
            "authorization": "jr_...",
            "require_approval": {"never": {"tool_names": ["scene_info", "render_preview", "render_estimate",
                                                         "render_status", "render_download"]}}}],
    input="Render a preview of https://render.janction.jp/samples/cube_scene.py and give me the image link.",
)
print(resp.output_text)

Anthropic Messages API (conector MCP; fallbacks="default" reexecuta uma solicitação recusada em um modelo de fallback):

import anthropic

client = anthropic.Anthropic()
response = client.beta.messages.create(
    model="claude-opus-5-5",
    max_tokens=16000,
    betas=["mcp-client-2025-11-20", "server-side-fallback-2026-07-01"],
    fallbacks="default",
    mcp_servers=[{"type": "url", "url": "https://render.janction.jp/mcp", "name": "janction-render",
                  "authorization_token": "jr_..."}],
    tools=[{"type": "mcp_toolset", "mcp_server_name": "janction-render"}],
    messages=[{"role": "user", "content": "Render a preview of https://render.janction.jp/samples/cube_scene.py"}],
)
for block in response.content:
    if block.type == "text":
        print(block.text)

Google ADK:

import os
from google.adk.agents import Agent
from google.adk.tools.mcp_tool import MCPToolset, StreamableHTTPConnectionParams

agent = Agent(
    name="renderer",
    model="gemini-2.5-flash",
    instruction="Render Blender scenes with JANCTION Render: preview first, ask before a final render.",
    tools=[MCPToolset(connection_params=StreamableHTTPConnectionParams(
        url="https://render.janction.jp/mcp",
        headers={"Authorization": "Bearer " + os.environ["JANCTION_RENDER_API_KEY"]}))],
)

Pydantic AI:

from pydantic_ai import Agent
from pydantic_ai.mcp import MCPToolset

render = MCPToolset("https://render.janction.jp/mcp", headers={"Authorization": "Bearer jr_..."})
agent = Agent("anthropic:claude-opus-5-5", toolsets=[render])

Conecte os aplicativos de IA neste computador em um comando, e informe a cada agente de codificação em um projeto quando e como renderizar:

uvx janction-render connect             # lists Claude Code, Codex, Gemini CLI, Cursor, Windsurf, VS Code and the step for each
uvx janction-render connect claude-code # applies one (or: connect all --yes)
uvx janction-render init                # writes a short section to AGENTS.md and adds the server to .mcp.json

init toca em CLAUDE.md, GEMINI.md, .cursor/ e .vscode/ apenas quando já existem (ou com --claude, --cursor, --vscode); ele mantém todo o resto nesses arquivos e faz backup do JSON que altera.

O servidor MCP local (stdio) também oferece prompts que aparecem como comandos de barra, por exemplo /mcp__janction-render__turntable_video no Claude Code: try_janction_render, render_my_scene, turntable_video, product_shots, scene_from_description, blend_to_mp4.

MCP

Remoto (Streamable HTTP, OAuth 2.1 com registro dinâmico de cliente; uma chave bruta também funciona como `Authorization: Bearer jr_...`)

cliente	como
Claude.ai (web, desktop, mobile)	Configurações → Conectores → Adicionar conector personalizado → cole a URL → Conectar
ChatGPT	Configurações → Conectores → Avançado → Modo desenvolvedor → Criar → cole a URL (OAuth)
Claude Code	`claude mcp add --transport http janction-render https://render.janction.jp/mcp`, depois `/mcp` para autenticar
Codex	`codex mcp add janction-render --url https://render.janction.jp/mcp`
Gemini CLI / Antigravity CLI	`gemini extensions install https://github.com/JasmyLab-JANCTION/janction-render` (este repositório carrega `gemini-extension.json`)
Grok (grok.com)	Conectores → Novo conector → Personalizado → cole a URL
Perplexity (Pro / Max / Enterprise), Le Chat (administrador do workspace)	Adicione um conector MCP remoto personalizado com a URL
Notion Agent (Business / Enterprise)	Configurações → Conexões → Descobrir → Adicionar MCP personalizado → cole a URL, depois entre (o botão aparece quando um administrador do workspace permite servidores MCP personalizados)
Cursor	`.cursor/mcp.json` (projeto) ou `~/.cursor/mcp.json`: `{"mcpServers": {"janction-render": {"url": "https://render.janction.jp/mcp"}}}`, depois entre quando o Cursor pedir (OAuth). Um clique: instalar no Cursor
VS Code (modo agente do Copilot)	`.vscode/mcp.json`: `{"servers": {"janction-render": {"type": "http", "url": "https://render.janction.jp/mcp"}}}` ou `code --add-mcp '{"name":"janction-render","type":"http","url":"https://render.janction.jp/mcp"}'`, depois Iniciar o servidor e entrar (OAuth)
Windsurf, Cline, Goose, outros clientes MCP	Streamable HTTP na URL acima (OAuth, ou um cabeçalho de chave de API Bearer). Notas do instalador: llms-install.md. Regra de projeto do Cursor (quando usar, fluxo de preview primeiro): integrations/cursor
Claude Desktop e outros clientes somente stdio (npm)	`{"mcpServers": {"janction-render": {"command": "npx", "args": ["-y", "janction-render"]}}}`: o pacote npm janction-render faz a ponte stdio para a URL acima com OAuth (`--key jr_...` para uma chave que você tem, `--local` para o servidor stdio Python via uv). Claude Code: `claude mcp add janction-render -- npx -y janction-render`

As ferramentas remotas aceitam scene_script (código bpy como texto), scene_url (um link https para um .blend, .py ou um arquivo 3D, ou um link de https://render.janction.jp/upload) ou scene_id, além de asset_urls para texturas ou arquivos glTF .bin. Os resultados retornam como uma imagem inline mais links de download que não precisam de chave e funcionam por cerca de 24 horas (render_download(only="mp4") apenas para o vídeo).

Plugin Claude Code (o conector remoto mais uma skill com o fluxo de trabalho):

/plugin marketplace add JasmyLab-JANCTION/janction-render
/plugin install janction-render@janction-render

Stdio (envia arquivos locais)

O pacote está no PyPI como janction-render (e o lançador npm janction-render o executa com npx -y janction-render --local quando uv está instalado).

# Claude Code (uvx runs it without a global install)
claude mcp add janction-render -e JANCTION_RENDER_SERVER=https://render.janction.jp -- uvx --from janction-render janction-render-mcp

# or with pip / pipx
pip install janction-render
claude mcp add janction-render -e JANCTION_RENDER_SERVER=https://render.janction.jp -- janction-render-mcp

Codex: adicione a ~/.codex/config.toml

[mcp_servers.janction-render]
command = "uvx"
args = ["--from", "janction-render", "janction-render-mcp"]
env = { JANCTION_RENDER_SERVER = "https://render.janction.jp" }

Uma chave de API temporária é emitida automaticamente no primeiro uso e armazenada em cache em ~/.janction-render.json; defina JANCTION_RENDER_API_KEY para fixar uma (cota e, depois, crédito pertencem à chave). A mesma chave pode ser usada no conector remoto: cole-a na página de conexão.

Ferramentas

ferramenta	o que faz
`scene_info(scene_script	scene_url
`render_preview(..., frames="1-24", environment?, blender?)`	até 4 quadros (orçamento de 720p) lado a lado com rótulos de quadro; retorna a imagem inline
`render_review(scene_path / scene_script / scene_url / scene_id, environment="studio")`	verifica um modelo 3D ou uma cena gerada de 4 lados (0/90/180/270 graus) sob luz de estúdio: passou / aviso / falhou, uma pontuação, as verificações que executou (arquivos, visibilidade, enquadramento, exposição, iluminação) com código de correção, e as 4 visualizações em uma imagem. Servidor stdio; mesmo tempo de GPU que uma pré-visualização
`render_estimate(scene_id, frame_start, frame_end, width, height, samples)`	segundos de GPU, espera na fila, "cerca de N minutos", cabe no tempo de GPU gratuito restante? Nenhum tempo de GPU usado
`render_final(scene_id, frame_start, frame_end, width, height, samples, fps, output, environment?, blender?, engine?, transparent?, notify_url?)`	quadros (png / exr) ou vídeo (mp4 / webm / prores / gif / webp); `transparent=True` mantém um fundo alfa (png / exr / webm / gif / webp); `notify_url` recebe um POST JSON quando o trabalho termina; retorna job_id + estimativa
`render_status(job_id)`	progresso e ETA (`eta.human`); `render_download(job_id, only="mp4" / "frames" / "all")` arquivos ou links; `render_cancel(job_id)`
`billing()`	o tempo de GPU gratuito restante (o crédito de boas-vindas, depois os minutos de pré-visualização gratuitos de hoje), o crédito, um link de recarga e o status de recarga automática e do plano mensal
`render_share(job_id, title?, note?, include_script?, listed?)`	uma página pública `/r/<id>` com a imagem ou vídeo, as condições e (opcionalmente) o script; sobrevive à expiração de 24 horas até `render_unshare`; com `listed=True` aparece em `/gallery` após uma revisão
`asset_search(query, kind)`	modelos / texturas / HDRIs CC0 no Poly Haven por palavras; os resultados trazem `polyhaven:<id>` e o arquivo de entrada
`render_info()`	trabalhadores online ou bloqueados (GPU emprestada para outra carga de trabalho), fila, espera esperada, entradas suportadas, predefinições de ambiente, versões do Blender

Opções em render_preview / render_final: environment (studio, sunset, overcast, night, compare em pré-visualizações; environment_strength, environment_visible=False para um fundo cinza plano com iluminação HDRI), orbit / orbit_frames / orbit_elevation (turntable), blender ("5.2"), e assets (stdio: arquivos locais enviados com a cena, encontrados no script através de os.environ["JR_ASSETS_DIR"]; os arquivos externos de um .blend são coletados automaticamente com pip install janction-render[blend]) ou asset_urls (remoto).

API

POST /v1/keys                                   -> {api_key}         (header X-API-Key afterwards)
POST /v1/files  multipart "file" (.blend|.py|.glb|.fbx|.usd|.obj|...)   -> {scene_id}
POST /v1/files/{id}/assets  multipart "files"   textures, glTF .bin ...   GET /v1/files/lookup?sha256=  reuse an upload
POST /v1/estimate {kind, frames|frame_start/frame_end, width, height, samples, scene_id?} -> seconds, wall_seconds, human, quota, currency, expires_at
POST /v1/jobs   {scene_id, kind: info|preview|final, frames|frame_start/frame_end, width, height, samples, camera, fps, output (png|exr|mp4|webm|prores|gif|webp), transparent, notify_url (https), engine (cycles|eevee),
                 environment, environment_strength, environment_visible, blender, orbit, orbit_frames, orbit_elevation}   header Idempotency-Key makes retries safe
GET  /v1/jobs/{id}      status, progress, eta, artifacts[], cost, warnings, info, failure (code + fix)    DELETE /v1/jobs/{id}  cancel
GET  /v1/jobs/{id}/artifacts/{name}             PNG / MP4
GET  /v1/jobs/{id}/archive?only=png             every file of the job in one zip (frame sequences: one request instead of hundreds)
GET  /v1/outcomes       fixed-price outcomes;  POST /v1/outcomes/turntable {scene_id, size, frames}   POST /v1/outcomes/product-shot {scene_id, size, transparent?}
POST /v1/try    JSON {scene_script | scene_url, frames?, width?, height?, environment?} (no key) -> first 720p preview + an API key to continue, in one response (1 per network per 24h)
POST /v1/drops  multipart "file" (no key)       -> a 12-hour https link to pass as scene_url (the /upload page uses this)
POST /v1/jobs/{id}/share {title?, note?, include_script?, listed?} -> {share_id, url}   DELETE /v1/jobs/{id}/share   GET /v1/shares
GET  /r/{share_id}  public page (no key)   GET /gallery
GET  /v1/assets/search?q=&kind=models|textures|hdris   CC0 assets (Poly Haven) -> spec polyhaven:<id>
POST /v1/files/{id}/assets/urls {urls: ["https://...", "polyhaven:<id>"]}   fetch assets server-side
GET  /v1/me  (quota, balance, limits)   POST /v1/me/limits {job_yen?, day_yen?}   spending caps per key
POST /mcp                                       remote MCP (Streamable HTTP; Bearer api key or OAuth)
GET  /.well-known/oauth-protected-resource/mcp  OAuth discovery
POST /v1/billing/checkout {amount_yen} -> {checkout_url}   POST /v1/billing/sync   GET /v1/ledger
GET  /openapi.json  /llms.txt  /llms-full.txt  /ja/llms.txt  /facts.json  /version.json  /capabilities.json  /pricing.json  /status.json

Um trabalho que ultrapassa o tempo de GPU gratuito sem crédito suficiente recebe 402 payment_required com checkout_url (mostre ao usuário), topup_yen e quanto do trabalho o tempo gratuito cobre; um 400 beta_limit significa que o trabalho é grande demais (divida-o). Todo erro de API carrega retryable, possible_fix e docs_url; um trabalho falho carrega failure com um código e a ação recomendada. Um trabalho acima de um limite de gastos é recusado com 403 spend_cap_exceeded antes que qualquer coisa seja reservada.

Exemplo

Um script de cena que o agente pode escrever (o serviço define motor, resolução, amostras e denoising; o script define a cena, câmera e intervalo de quadros):

import bpy, math
for ob in list(bpy.data.objects):
    bpy.data.objects.remove(ob, do_unlink=True)
scene = bpy.context.scene
scene.frame_start, scene.frame_end = 1, 24
bpy.ops.mesh.primitive_monkey_add(location=(0, 0, 1))
cam = bpy.data.objects.new("Camera", bpy.data.cameras.new("Camera"))
scene.collection.objects.link(cam); scene.camera = cam
cam.location = (6, -6, 4); cam.rotation_euler = (math.radians(60), 0, math.radians(45))
sun = bpy.data.objects.new("Sun", bpy.data.lights.new("Sun", "SUN"))
scene.collection.objects.link(sun)

Cycles por padrão; engine="eevee" para animações mais baratas (cerca de metade do custo por quadro após ~7 s de compilação de shader por trabalho). No Blender 5.0, os materiais sempre usam nós: defina a Cor Base do Principled BSDF, não diffuse_color. Os scripts rodam em um contêiner isolado sem rede. Mais: samples/cube_scene.py, samples/polyhaven_room.py. Tempos medidos: https://render.janction.jp/benchmarks

Preços

Uma nova chave começa com um crédito de boas-vindas de 100 JPY (1.000 segundos de GPU, 14 dias, sem cartão) que cobre pré-visualizações e finais; um crédito completo por rede a cada 30 dias (chaves posteriores na mesma rede compartilham o que resta dele). Salvar um cartão em uma página Stripe que não cobra nada adiciona 400 JPY a mais, uma vez por cartão (até 500 JPY no total). Depois que é usado ou expira, as pré-visualizações são gratuitas até 2 minutos de GPU por dia e os finais custam 0,1 JPY por segundo de GPU de crédito pré-pago, comprado por cartão em uma página de Checkout Stripe (a partir de 500 JPY; 2.000 JPY dá 2.200 JPY de crédito, 5.000 dá 5.750, 10.000 dá 12.000; a primeira recarga no período de boas-vindas conta 1,5x, bônus até 500 JPY). Apenas a parte que o tempo gratuito não cobre é cobrada. Os finais vão até 3.000 quadros por instrução (executados como partes de 240 sob um id de trabalho): 1080p no tempo gratuito, até 4K (3840x2160) com crédito pré-pago. POST /v1/estimate cita o que será cobrado (cost.estimated_yen), a moeda e uma expiração antes de qualquer tempo de GPU ser usado: https://render.janction.jp/pricing

Solução de problemas

Você vê	O que significa	O que fazer
`402 payment_required`	O trabalho ultrapassa o crédito gratuito restante na chave	`tell_user` na resposta diz quanto esta renderização custa e o que uma recarga compra; pague em `checkout_url` (a partir de 500 JPY) e envie o mesmo trabalho novamente, ou renderize menos quadros / uma resolução menor
`script_blocked`	O script bpy usa algo que o sandbox recusa (rede, processos, ctypes)	O trabalhador de GPU não tem rede: passe arquivos da web em `asset_urls=[...]` (MCP) ou `POST /v1/files/{scene_id}/assets/urls`, depois abra-os com `jr_assets.path('<name>')`. Um script recusado apenas por `urllib` / `requests` não conta para revogar a chave
`script_path` / `scene_path`	A cena aponta para um arquivo no seu próprio computador	Envie o arquivo como um ativo e referencie-o pelo nome (caminho relativo)
`McpError: Timed out while waiting for response` (OpenAI Agents SDK)	O SDK espera 5 segundos por uma ferramenta por padrão	`MCPServerStreamableHttp(..., client_session_timeout_seconds=120)` (veja "Do seu próprio agente ou aplicativo")
O trabalho fica em `queued` e `eta.human` diz que a GPU está emprestada	A GPU está compartilhada com outra carga de trabalho por um tempo	Diga ao usuário a espera; chame `render_download(job_id, wait_seconds=45)` mais tarde em vez de fazer polling
`429 rate_limited`	Muitas solicitações em um curto período	Espere por `Retry-After` segundos e envie novamente
Muito escuro, estourado, ou o objeto fora do quadro	O veredito da pré-visualização diz qual, com código bpy para corrigir	Aplique a correção e pré-visualize novamente (segundos) antes do final; arquivos 3D são enquadrados no tamanho real automaticamente
`401` do Claude, ChatGPT ou Codex	O login do conector expirou	Reconecte o conector (`/mcp` no Claude Code), ou passe a chave como `X-API-Key` / `Authorization: Bearer jr_...`

Documentação

Ficha técnica (a fonte primária quando as respostas discordam): https://render.janction.jp/facts · JSON: /facts.json, /version.json, /changelog.json, /status.json
Para agentes: https://render.janction.jp/llms.txt (texto completo de todos os guias: /llms-full.txt)
Guias: render farm para agentes · sem GPU · Cycles é lento no meu MacBook · Claude · ChatGPT · Claude Code · Codex · Cursor · scripts bpy · API · comparar · produtos · 日本語 é /ja/
Status: https://render.janction.jp/status · Segurança e retenção: https://render.janction.jp/security · Changelog: https://render.janction.jp/changelog

Recursos em detalhe

Entrada: um arquivo .blend (texturas viajam com ele), um script Python bpy que constrói a cena (sem Blender local necessário), ou um arquivo 3D (glTF/GLB, FBX, USD, OBJ, STL, PLY, Alembic) que é importado em uma cena vazia.
environment="studio" | "sunset" | "overcast" | "night" ilumina uma cena com um HDRI incluído (CC0) para uma boa primeira renderização; environment="compare" pré-visualiza o mesmo quadro sob todas as quatro predefinições em uma imagem rotulada, para o agente escolher uma.
Um .gltf ou .obj traz seu .bin / .mtl / texturas automaticamente (da mesma pasta ou da mesma pasta de URL).
orbit=True transforma qualquer cena ou modelo importado em um turntable: uma câmera orbital circula uma vez (orbit_frames, padrão 24; uma pré-visualização mostra 0/90/180/270 graus, uma renderização final sem frame_end dá a volta inteira como MP4). Pisos planos e paredes são ignorados ao enquadrar; orbit_target (nome do objeto ou x,y,z) e orbit_distance (multiplicador) ajustam a tomada.
Enquanto a GPU está emprestada para outra carga de trabalho, as ferramentas respondem imediatamente com o trabalho na fila e uma estimativa de espera (há quanto tempo está fora, quanto tempo normalmente fica fora, quanto mais esperar; eta.gate) em vez de esperar.
Enquanto um trabalho renderiza, render_status conta quadros concluídos dentro do bloco em execução, então o ETA atualiza a cada poucos segundos.
Em hosts que suportam MCP Apps (Claude web e desktop, entre outros), pré-visualizações, progresso e links de download também aparecem como um painel interativo no chat: a imagem, uma barra de progresso, "Abrir MP4" e botões de predefinição após uma pré-visualização environment="compare". Tanto o conector remoto quanto o pacote stdio enviam o painel (janction_render/mcp_app.html); defina JR_MCP_APPS=0 para desligá-lo.
Ativos CC0 por nome: asset_search("wooden table") encontra modelos, texturas e HDRIs do Poly Haven; passe polyhaven:<id> em asset_urls (remoto) ou assets (stdio) e os arquivos caem em JR_ASSETS_DIR/<id>/ na GPU, prontos para importar (bpy.ops.import_scene.gltf(filepath=os.path.join(os.environ['JR_ASSETS_DIR'], 'wooden_table_02', 'wooden_table_02_1k.gltf'))). Scripts de cena podem import jr_assets para one-liners: jr_assets.import_model('wooden_table_02'), jr_assets.apply(floor, jr_assets.material('wood_floor_deck', scale=2)) (diff / normal / roughness / metal conectados a um Principled BSDF), jr_assets.world_hdri('studio_small_09'). Veja samples/polyhaven_room.py.
Uma renderização que você escolher compartilhar (render_share) ganha uma página pública (/r/<id>, OGP para X e Discord) que permanece até você descompartilhar.
Blender 5.0, Cycles na GPU (blender="5.2" seleciona Blender 5.2 quando o trabalhador tem; render_info lista o que está disponível).

Add-on do Blender e ferramentas DCC (para pessoas, não agentes)

Extensão do Blender (addons/blender/, Blender 4.2+): um painel JANCTION Render em Propriedades → Renderizar com Pré-visualização, Estimativa e Final. Uma cópia do arquivo aberto e as texturas que ele referencia com caminhos relativos são enviadas; os resultados caem ao lado do .blend. Instale do repositório de extensões https://render.janction.jp/extensions/index.json (Preferências → Obter Extensões → Repositórios → + → Adicionar Repositório Remoto), ou instale o zip de https://render.janction.jp/extensions/janction_render-0.1.2.zip (python scripts/build_blender_addon.py o constrói deste repositório). Guia: https://render.janction.jp/blender-addon
Maya, Houdini, Cinema 4D (integrations/): exporte para USD / FBX / Alembic, envie com texturas, renderize com Cycles, abra o resultado; Pré-visualização, Final (MP4) e Turntable. Apenas Python da biblioteca padrão; jr_submit.py é o cliente compartilhado. Guia: https://render.janction.jp/maya-houdini-cinema4d

Auto-hospedagem

O servidor (FastAPI + SQLite, com o endpoint MCP remoto) e o trabalhador (Blender em contêineres Docker descartáveis, --network none --cap-drop ALL) vivem no repositório interno e não fazem parte deste pacote ainda. Este repositório contém o lado do cliente: servidor MCP stdio, CLI, cliente HTTP, amostras, o plugin do Claude Code, o add-on do Blender e as ferramentas DCC.

Registro MCP

Este servidor está listado no registro MCP oficial como io.github.JasmyLab-JANCTION/janction-render (remoto: https://render.janction.jp/mcp).

mcp-name: io.github.JasmyLab-JANCTION/janction-render

Segurança

Relatórios de vulnerabilidade: veja SECURITY.md. Retenção, isolamento e os testes externos são resumidos na página de segurança.

Licença

MIT (veja LICENSE) para o pacote, os servidores MCP, o CLI e as ferramentas DCC. A extensão do Blender sob addons/blender/ é GPL-3.0-or-later, como o Blender exige para add-ons. Operado por JasmyLab Inc.

JANCTION Render

Servidor MCP hospedado

Documentação

JANCTION Render

O que é o JANCTION Render?

O que um comando gera (saídas reais)

Guias no site oficial

Por que usar?

Início rápido

Do seu próprio agente ou aplicativo

MCP

Remoto (Streamable HTTP, OAuth 2.1 com registro dinâmico de cliente; uma chave bruta também funciona como Authorization: Bearer jr_...)

Stdio (envia arquivos locais)

Ferramentas

API

Exemplo

Preços

Solução de problemas

Documentação

Recursos em detalhe

Add-on do Blender e ferramentas DCC (para pessoas, não agentes)

Auto-hospedagem

Registro MCP

Segurança

Licença

Remoto (Streamable HTTP, OAuth 2.1 com registro dinâmico de cliente; uma chave bruta também funciona como `Authorization: Bearer jr_...`)