JANCTION Render

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

JANCTION Render

¿Qué es JANCTION Render?

JANCTION Render es una granja de renderizado GPU en la nube para Blender que los agentes de IA invocan como servidor MCP o API HTTP. Envía un archivo .blend, un script bpy o un archivo 3D (glTF / FBX / USD), obtén una vista previa en segundos, y recibe fotogramas o un MP4 desde las GPU NVIDIA de JANCTION. Cada vista previa también devuelve un veredicto sobre qué está mal, como demasiado oscuro, sobreexplotado, sin luz o un objeto fuera de cuadro, y el código bpy para corregirlo, para que el agente pueda corregir la escena antes del renderizado final. No se necesita Blender local ni GPU. Un crédito de bienvenida de 100 JPY para una clave nueva (una por red cada 30 días; las claves adicionales en la misma red comparten lo que queda) y 400 JPY más por guardar una tarjeta que no se cobra (una vez por tarjeta), luego 0,1 JPY por segundo de GPU (vistas previas gratuitas hasta 2 minutos de GPU al día); operado por JasmyLab Inc.

Los agentes de IA pueden renderizar proyectos de Blender en las GPU de JANCTION sin ejecutar Blender localmente. Funciona desde Claude, ChatGPT, Claude Code, Codex, Cursor o cualquier cliente MCP: un servidor MCP (remoto y stdio), una API HTTP y una CLI.

JANCTION Render es un producto separado de SmartRender (el renderizado distribuido de JasmyLab para personas en un escritorio) y no está afiliado con Render.com ni con Render Network. Los números, a fecha de 2026-10-08 (la fuente principal es https://render.janction.jp/facts.json): un crédito de bienvenida de 100 JPY (1.000 segundos de GPU, 14 días, sin tarjeta) para una clave nueva, una por red cada 30 días (las claves adicionales en la misma red comparten lo que queda), más 400 JPY adicionales una vez que se guarda una tarjeta en una página que no cobra nada (una vez por tarjeta); después de eso, las vistas previas son gratuitas hasta 2 minutos de GPU al día y los renderizados finales cuestan 0,1 JPY por segundo de GPU desde crédito prepagado (el uso de pago comenzó el 2026-10-08); renderizados finales de hasta 3.000 fotogramas por instrucción (ejecutados en partes de 240 bajo un mismo ID de trabajo); 1080p en tiempo gratuito, hasta 4K con crédito prepagado; las entradas y los resultados se eliminan 24 horas después del último uso (7 días, normalmente, para claves que han pagado 500 JPY o más en total).

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

Pruébalo desde una terminal en unos segundos, gratis y sin necesidad de registrarte (requiere uv; o pip install janction-render y suelta el 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)

Lo que produce un comando (resultados reales)

Renderizado el 2026-10-10 en la GPU de producción (NVIDIA RTX PRO 6000 Blackwell) a partir de la muestra WaterBottle de Khronos (dominio público, CC0); copia cualquier línea y se ejecuta tal cual. Los precios son de 0,1 JPY por segundo de GPU y están cubiertos por el crédito de bienvenida de una clave nueva.

	Comando	Tiempo de GPU	Precio
	uvx janction-render shots https://github.com/KhronosGroup/glTF-Sample-Assets/blob/main/Models/WaterBottle/glTF-Binary/WaterBottle.glb	13,9 s	aproximadamente 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	aproximadamente 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	aproximadamente 5,4 JPY

Las tomas son cuatro PNG de 1920x1080; el plato giratorio y la animación son MP4 (mostrados aquí como GIF). Tu propio .glb, .blend o script bpy va en lugar del enlace. Más, con sus scripts: https://render.janction.jp/examples

¿Tienes archivos 3D en un repositorio? Añade un botón que permita a cualquiera renderizarlos desde su propia IA o terminal (los enlaces a páginas de archivos en GitHub y Hugging Face funcionan tal cual; crea uno en 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)

Guías en el sitio oficial

• Cómo renderizar Blender sin GPU
• Desde un agente: Claude Code + Blender · Codex + Blender · Cursor + Blender · ChatGPT + Blender · Servidor MCP de Blender para renderizado
• Las mejores granjas de renderizado para agentes de IA (2026): JANCTION, BlendSwap, Sceneplane, tu propio worker en Modal o RunPod y un Blender MCP local lado a lado
• Blender sin interfaz como API · glTF, GLB o FBX a MP4 · Video de producto de 360 grados · Cuánto cuesta un renderizado de Blender
• Ejemplos con sus scripts bpy · Comparar · 日本語のご案内

¿Por qué usarlo?

• Sin GPU, sin instalación de Blender. La escena puede ser un script bpy que el agente escribe, un .blend, o un archivo 3D; Blender se ejecuta en nuestras GPU.
• Diseñado para agentes. Vista previa primero (1-4 fotogramas en unos pocos segundos de GPU), una estimación con tiempo y costo antes del renderizado final, errores estructurados con la corrección, límites de gasto por clave, reintentos seguros con Idempotency-Key.
• Archivos 3D y platos giratorios. glTF / GLB, FBX, USD, OBJ, STL, PLY, Alembic se importan en una escena vacía con cámara e iluminación HDRI; orbit=True crea un plato giratorio. Resultados a precio fijo: POST /v1/outcomes/turntable y /product-shot.
• Límites honestos. un crédito de bienvenida de 100 JPY para una clave nueva sin tarjeta (14 días; una por red cada 30 días) y 400 JPY más después de guardar una tarjeta que no se cobra, luego 0,1 JPY por segundo de GPU (vistas previas gratuitas hasta 2 minutos de GPU al día), renderizados finales de hasta 3.000 fotogramas por instrucción en partes de 240 (1080p en tiempo gratuito, hasta 4K con crédito prepagado), en las GPU propias de JANCTION (NVIDIA RTX PRO 6000 Blackwell); cuando están ocupadas, los trabajos esperan en una cola y el ETA lo indica. Las entradas y los resultados se eliminan 24 horas después del último uso (7 días, normalmente, para claves que han pagado 500 JPY o más en total) y nunca se usan para entrenamiento.
• No es Render.com. Misma palabra, producto diferente.

Inicio rápido

Claude.ai / ChatGPT (nada que instalar). Configuración → Conectores → añadir https://render.janction.jp/mcp → Conectar (se crea una clave gratuita en la página de consentimiento). Luego pega:

Renderiza una vista previa de https://render.janction.jp/samples/cube_scene.py

Una vista previa de 4 fotogramas llega en unos segundos. Un archivo en tu computadora: suéltalo en https://render.janction.jp/upload para obtener un enlace de 12 horas, luego "Renderiza este archivo: ".

Claude Code.

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

Luego /mcp para autenticarte y pregunta: "Construye una pequeña escena callejera en Blender con un recorrido de cámara y renderiza una vista previa con janction-render."

HTTP (cualquier lenguaje).

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}

Desde tu propio agente o aplicación

Python (pip install janction-render; la primera llamada crea una clave gratuita y la guarda en ~/.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"))

Pago por uso con crédito prepagado; no se necesita suscripción (precios: https://render.janction.jp/pricing). En lugar de sondear, pasa notify_url (https) a POST /v1/jobs y recibe un JSON POST cuando el trabajo termine (job.done / job.failed, con enlaces de descarga); un encabezado Idempotency-Key hace que los reintentos sean seguros. OpenAPI: https://render.janction.jp/openapi.json Un ejemplo de aplicación completa (un usuario sube un GLB, la aplicación solicita tomas de producto a precio fijo, un webhook almacena las imágenes): https://render.janction.jp/blender-render-api#embed

Los frameworks de agentes se conectan al servidor MCP remoto en https://render.janction.jp/mcp con la clave como token bearer (curl -s -X POST https://render.janction.jp/v1/keys da una, sin registro).

OpenAI Agents SDK (mantén el tiempo de espera más largo: render_preview espera la imagen, más que el predeterminado 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 sigue pidiendo aprobación 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" reejecuta una solicitud rechazada en un modelo de respaldo):

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])

Conecta las aplicaciones de IA en esta computadora con un comando, y dile a cada agente de codificación en un proyecto cuándo y cómo 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 CLAUDE.md, GEMINI.md, .cursor/ y .vscode/ solo cuando ya existen (o con --claude, --cursor, --vscode); conserva todo lo demás en esos archivos y respalda el JSON que cambia.

El servidor MCP local (stdio) también ofrece prompts que aparecen como comandos de barra, por ejemplo /mcp__janction-render__turntable_video en 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 con registro dinámico de clientes; una clave cruda también funciona como Authorization: Bearer jr_...)

cliente	cómo
Claude.ai (web, escritorio, móvil)	Configuración → Conectores → Añadir conector personalizado → pegar la URL → Conectar
ChatGPT	Configuración → Conectores → Avanzado → Modo desarrollador → Crear → pegar la URL (OAuth)
Claude Code	claude mcp add --transport http janction-render https://render.janction.jp/mcp, luego /mcp para autenticarte
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 repositorio incluye gemini-extension.json)
Grok (grok.com)	Conectores → Nuevo conector → Personalizado → pegar la URL
Perplexity (Pro / Max / Enterprise), Le Chat (administrador del espacio de trabajo)	Añadir un conector MCP remoto personalizado con la URL
Notion Agent (Business / Enterprise)	Configuración → Conexiones → Descubrir → Añadir MCP personalizado → pegar la URL, luego iniciar sesión (el botón aparece cuando un administrador del espacio de trabajo permite servidores MCP personalizados)
Cursor	.cursor/mcp.json (proyecto) o ~/.cursor/mcp.json: {"mcpServers": {"janction-render": {"url": "https://render.janction.jp/mcp"}}}, luego inicia sesión cuando Cursor lo pida (OAuth). Un clic: instalar en Cursor
VS Code (modo agente de Copilot)	.vscode/mcp.json: {"servers": {"janction-render": {"type": "http", "url": "https://render.janction.jp/mcp"}}} o code --add-mcp '{"name":"janction-render","type":"http","url":"https://render.janction.jp/mcp"}', luego inicia el servidor e inicia sesión (OAuth)
Windsurf, Cline, Goose, otros clientes MCP	Streamable HTTP en la URL anterior (OAuth, o un encabezado de clave API Bearer). Notas del instalador: llms-install.md. Regla de proyecto de Cursor (cuándo usarlo, flujo de vista previa primero): integrations/cursor
Claude Desktop y otros clientes solo stdio (npm)	{"mcpServers": {"janction-render": {"command": "npx", "args": ["-y", "janction-render"]}}}: el paquete npm janction-render conecta stdio a la URL anterior con OAuth (--key jr_... para una clave que tengas, --local para el servidor stdio de Python a través de uv). Claude Code: claude mcp add janction-render -- npx -y janction-render

Las herramientas remotas aceptan scene_script (código bpy como texto), scene_url (un enlace https a un .blend, .py o un archivo 3D, o un enlace de https://render.janction.jp/upload) o scene_id, más asset_urls para texturas o archivos glTF .bin. Los resultados llegan como una imagen en línea más enlaces de descarga que no requieren clave y funcionan durante aproximadamente 24 horas (render_download(only="mp4") solo para el video).

Plugin de Claude Code (el conector remoto más una habilidad con el flujo de trabajo):

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

Stdio (envía archivos locales)

El paquete está en PyPI como janction-render (y el lanzador npm janction-render lo ejecuta con npx -y janction-render --local cuando 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: añadir 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" }

Se emite automáticamente una clave API temporal en el primer uso y se guarda en caché en ~/.janction-render.json; establece JANCTION_RENDER_API_KEY para fijar una (la cuota y, más tarde, el crédito pertenecen a la clave). La misma clave se puede usar desde el conector remoto: pégala en la página de conexión.

Herramientas

herramienta	qué hace
`scene_info(scene_script	scene_url
render_preview(..., frames="1-24", environment?, blender?)	hasta 4 fotogramas (presupuesto de 720p) en mosaico con etiquetas de fotograma; devuelve la imagen en línea
render_review(scene_path / scene_script / scene_url / scene_id, environment="studio")	comprueba un modelo 3D o una escena generada desde 4 lados (0/90/180/270 grados) bajo luz de estudio: aprobado / advertencia / fallo, una puntuación, las comprobaciones que ejecutó (archivos, visibilidad, encuadre, exposición, iluminación) con código de corrección, y las 4 vistas en una imagen. Servidor stdio; mismo tiempo de GPU que una vista previa
render_estimate(scene_id, frame_start, frame_end, width, height, samples)	segundos de GPU, espera en cola, "aproximadamente N minutos", ¿cabe en el tiempo de GPU gratuito restante? Sin uso de tiempo de GPU
render_final(scene_id, frame_start, frame_end, width, height, samples, fps, output, environment?, blender?, engine?, transparent?, notify_url?)	fotogramas (png / exr) o video (mp4 / webm / prores / gif / webp); transparent=True mantiene un fondo alfa (png / exr / webm / gif / webp); notify_url recibe un POST JSON cuando el trabajo termina; devuelve job_id + estimación
render_status(job_id)	progreso y ETA (eta.human); render_download(job_id, only="mp4" / "frames" / "all") archivos o enlaces; render_cancel(job_id)
billing()	el tiempo de GPU gratuito restante (el crédito de bienvenida, luego los minutos de vista previa gratuitos de hoy), el crédito, un enlace de recarga y el estado de recarga automática y plan mensual
render_share(job_id, title?, note?, include_script?, listed?)	una página pública /r/<id> con la imagen o video, las condiciones y (opcionalmente) el script; sobrevive a la caducidad de 24 horas hasta render_unshare; con listed=True aparece en /gallery después de una revisión
asset_search(query, kind)	modelos / texturas / HDRIs CC0 en Poly Haven por palabras; los resultados llevan polyhaven:<id> y el archivo de entrada
render_info()	trabajadores en línea o bloqueados (GPU prestada a otra carga de trabajo), cola, espera esperada, entradas compatibles, preajustes de entorno, versiones de Blender

Opciones en render_preview / render_final: environment (studio, sunset, overcast, night, compare en vistas previas; environment_strength, environment_visible=False para un fondo gris plano con iluminación HDRI), orbit / orbit_frames / orbit_elevation (tornamesa), blender ("5.2"), y assets (stdio: archivos locales enviados con la escena, encontrados en el script a través de os.environ["JR_ASSETS_DIR"]; los archivos externos de un .blend se recopilan automáticamente con pip install janction-render[blend]) o asset_urls (remoto).

CLI: janction-render inspect|preview|render|status|download|share|unshare|cancel|jobs|balance|topup|limits|outcomes|info.

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

Un trabajo que supera el tiempo de GPU gratuito sin suficiente crédito recibe 402 payment_required con checkout_url (muéstralo al usuario), topup_yen y cuánto del trabajo cubre el tiempo gratuito; un 400 beta_limit significa que el trabajo es demasiado grande (divídelo). Cada error de API lleva retryable, possible_fix y docs_url; un trabajo fallido lleva failure con un código y la acción recomendada. Un trabajo que supera un límite de gasto se rechaza con 403 spend_cap_exceeded antes de reservar nada.

Ejemplo

Un script de escena que el agente puede escribir (el servicio establece motor, resolución, muestras y denoising; el script establece la escena, cámara y rango de fotogramas):

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 defecto; engine="eevee" para animaciones más baratas (aproximadamente la mitad del costo por fotograma después de ~7 s de compilación de shaders por trabajo). En Blender 5.0 los materiales siempre usan nodos: establece el Color Base del Principled BSDF, no diffuse_color. Los scripts se ejecutan en un contenedor aislado sin red. Más: samples/cube_scene.py, samples/polyhaven_room.py. Tiempos medidos: https://render.janction.jp/benchmarks

Precios

Una nueva clave comienza con un crédito de bienvenida de 100 JPY (1,000 segundos de GPU, 14 días, sin tarjeta) que cubre vistas previas y finales; un crédito completo por red cada 30 días (las claves posteriores en la misma red comparten lo que queda). Guardar una tarjeta en una página de Stripe que no cobra nada añade 400 JPY más, una vez por tarjeta (hasta 500 JPY en total). Después de que se agote o caduque, las vistas previas son gratuitas hasta 2 minutos de GPU al día y los finales cuestan 0.1 JPY por segundo de GPU de crédito prepagado, comprado con tarjeta en una página de Stripe Checkout (desde 500 JPY; 2,000 JPY da 2,200 JPY de crédito, 5,000 da 5,750, 10,000 da 12,000; la primera recarga en el período de bienvenida cuenta 1.5x, bonificación hasta 500 JPY). Solo se cobra la parte que el tiempo gratuito no cubre. Los finales llegan hasta 3,000 fotogramas por instrucción (ejecutados como partes de 240 bajo un id de trabajo): 1080p en tiempo gratuito, hasta 4K (3840x2160) con crédito prepagado. POST /v1/estimate cotiza lo que se cobrará (cost.estimated_yen), la moneda y una caducidad antes de usar cualquier tiempo de GPU: https://render.janction.jp/pricing

Solución de problemas

Ves	Qué significa	Qué hacer
402 payment_required	El trabajo supera el crédito gratuito restante en la clave	tell_user en la respuesta dice cuánto cuesta este render y qué compra una recarga; paga en checkout_url (desde 500 JPY) y envía el mismo trabajo de nuevo, o renderiza menos fotogramas / una resolución más baja
script_blocked	El script bpy usa algo que el sandbox rechaza (red, procesos, ctypes)	El trabajador de GPU no tiene red: pasa archivos desde la web en asset_urls=[...] (MCP) o POST /v1/files/{scene_id}/assets/urls, luego ábrelos con jr_assets.path('<name>'). Un script rechazado solo por urllib / requests no cuenta para revocar la clave
script_path / scene_path	La escena apunta a un archivo en tu propia computadora	Envía el archivo como un activo y refiérelo por nombre (ruta relativa)
McpError: Timed out while waiting for response (OpenAI Agents SDK)	El SDK espera 5 segundos por una herramienta por defecto	MCPServerStreamableHttp(..., client_session_timeout_seconds=120) (ver "Desde tu propio agente o aplicación")
El trabajo está en queued y eta.human dice que la GPU está prestada	La GPU se comparte con otra carga de trabajo por un tiempo	Informa al usuario de la espera; llama a render_download(job_id, wait_seconds=45) más tarde en lugar de sondear
429 rate_limited	Demasiadas solicitudes en poco tiempo	Espera Retry-After segundos y envía de nuevo
Demasiado oscuro, sobreexpuesto, o el objeto fuera de cuadro	El veredicto de la vista previa dice cuál, con código bpy para corregirlo	Aplica la corrección y previsualiza de nuevo (segundos) antes del final; los archivos 3D se encuadran a su tamaño real automáticamente
401 de Claude, ChatGPT o Codex	La sesión del conector caducó	Reconecta el conector (/mcp en Claude Code), o pasa la clave como X-API-Key / Authorization: Bearer jr_...

Documentación

• Hoja de datos (la fuente principal cuando las respuestas difieren): 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 todas las guías: /llms-full.txt)
• Guías: granja de render para agentes · sin GPU · Cycles es lento en mi MacBook · Claude · ChatGPT · Claude Code · Codex · Cursor · scripts bpy · API · comparar · productos · 日本語 es /ja/
• Estado: https://render.janction.jp/status · Seguridad y retención: https://render.janction.jp/security · Registro de cambios: https://render.janction.jp/changelog

Características en detalle

• Entrada: un archivo .blend (las texturas viajan con él), un script Python bpy que construye la escena (sin Blender local necesario), o un archivo 3D (glTF/GLB, FBX, USD, OBJ, STL, PLY, Alembic) que se importa en una escena vacía.
• environment="studio" | "sunset" | "overcast" | "night" ilumina una escena con un HDRI incluido (CC0) para un buen primer render; environment="compare" previsualiza el mismo fotograma bajo los cuatro preajustes en una imagen etiquetada, para que el agente pueda elegir uno.
• Un .gltf o .obj trae sus .bin / .mtl / texturas automáticamente (desde la misma carpeta o la misma carpeta de URL).
• orbit=True convierte cualquier escena o modelo importado en una tornamesa: una cámara orbital lo rodea una vez (orbit_frames, por defecto 24; una vista previa muestra 0/90/180/270 grados, un render final sin frame_end da toda la vuelta como MP4). Los pisos planos y paredes se ignoran al encuadrar; orbit_target (nombre de objeto o x,y,z) y orbit_distance (multiplicador) ajustan la toma.
• Mientras la GPU está prestada a otra carga de trabajo, las herramientas responden de inmediato con el trabajo en cola y una estimación de espera (cuánto tiempo ha estado fuera, cuánto tiempo suele estar fuera, cuánto más esperar; eta.gate) en lugar de esperar.
• Mientras un trabajo renderiza, render_status cuenta los fotogramas terminados dentro del fragmento en ejecución, por lo que la ETA se actualiza cada pocos segundos.
• En hosts que admiten MCP Apps (Claude web y escritorio, entre otros), las vistas previas, el progreso y los enlaces de descarga también aparecen como un panel interactivo en el chat: la imagen, una barra de progreso, "Abrir MP4" y botones de preajuste después de una vista previa environment="compare". Tanto el conector remoto como el paquete stdio incluyen el panel (janction_render/mcp_app.html); establece JR_MCP_APPS=0 para desactivarlo.
• Activos CC0 por nombre: asset_search("wooden table") encuentra modelos, texturas y HDRIs de Poly Haven; pasa polyhaven:<id> en asset_urls (remoto) o assets (stdio) y los archivos aterrizan en JR_ASSETS_DIR/<id>/ en la GPU, listos para importar (bpy.ops.import_scene.gltf(filepath=os.path.join(os.environ['JR_ASSETS_DIR'], 'wooden_table_02', 'wooden_table_02_1k.gltf'))). Los scripts de escena pueden import jr_assets para una línea: 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 un Principled BSDF), jr_assets.world_hdri('studio_small_09'). Ver samples/polyhaven_room.py.
• Un render que elijas compartir (render_share) obtiene una página pública (/r/<id>, OGP para X y Discord) que permanece hasta que dejes de compartirlo.
• Blender 5.0, Cycles en GPU (blender="5.2" selecciona Blender 5.2 cuando el trabajador lo tiene; render_info lista lo que está disponible).

Complemento de Blender y herramientas DCC (para personas, no agentes)

• Extensión de Blender (addons/blender/, Blender 4.2+): un panel JANCTION Render en Propiedades → Render con Vista Previa, Estimación y Final. Se suben una copia del archivo abierto y las texturas que referencia con rutas relativas; los resultados aterrizan junto al .blend. Instala desde el repositorio de extensiones https://render.janction.jp/extensions/index.json (Preferencias → Obtener Extensiones → Repositorios → + → Agregar Repositorio Remoto), o instala el zip desde https://render.janction.jp/extensions/janction_render-0.1.2.zip (python scripts/build_blender_addon.py lo construye desde este repositorio). Guía: https://render.janction.jp/blender-addon
• Maya, Houdini, Cinema 4D (integrations/): exporta a USD / FBX / Alembic, sube con texturas, renderiza con Cycles, abre el resultado; Vista Previa, Final (MP4) y Tornamesa. Solo Python de biblioteca estándar; jr_submit.py es el cliente compartido. Guía: https://render.janction.jp/maya-houdini-cinema4d

Autoalojamiento

El servidor (FastAPI + SQLite, con el endpoint MCP remoto) y el trabajador (Blender en contenedores Docker desechables, --network none --cap-drop ALL) viven en el repositorio interno y no son parte de este paquete aún. Este repositorio contiene el lado del cliente: servidor MCP stdio, CLI, cliente HTTP, ejemplos, el plugin de Claude Code, el complemento de Blender y las herramientas DCC.

Registro MCP

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

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

Seguridad

Informes de vulnerabilidades: ver SECURITY.md. Retención, aislamiento y las pruebas externas se resumen en la página de seguridad.

Licencia

MIT (ver LICENSE) para el paquete, los servidores MCP, el CLI y las herramientas DCC. La extensión de Blender bajo addons/blender/ es GPL-3.0-o-posterior, como Blender requiere para complementos. Operado por JasmyLab Inc.