# DeepSeek V4 Pro — Scenepond API Model ID: `deepseek-v4-pro` Model developer: DeepSeek Source page: https://open.scenepond.ai/en/models/deepseek-v4-pro#api Reviewed: 2026-10-01 Base URL: `https://scenepond-api-production.up.railway.app/v1` Authenticate every request with Authorization: Bearer and your Scenepond API key. Keep the key on your server. ## Chat Completions `POST /v1/chat/completions` ### Minimum request #### cURL ```bash curl --fail-with-body -X POST "https://scenepond-api-production.up.railway.app/v1/chat/completions" \ -H "Authorization: Bearer $SCENEPOND_API_KEY" \ -H "Content-Type: application/json" \ --data-binary @- <<'JSON' { "model": "deepseek-v4-pro", "messages": [ { "role": "user", "content": "Hello" } ] } JSON ``` #### Python ```python import os import json from urllib.parse import quote from urllib.request import Request, urlopen payload = json.loads("{\n \"model\": \"deepseek-v4-pro\",\n \"messages\": [\n {\n \"role\": \"user\",\n \"content\": \"Hello\"\n }\n ]\n}") request = Request( "https://scenepond-api-production.up.railway.app/v1/chat/completions", headers={ "Authorization": "Bearer " + os.environ["SCENEPOND_API_KEY"], "Content-Type": "application/json", }, data=json.dumps(payload).encode("utf-8"), method="POST", ) with urlopen(request) as response: result = json.load(response) print(json.dumps(result, indent=2)) ``` #### JavaScript ```javascript const response = await fetch("https://scenepond-api-production.up.railway.app/v1/chat/completions", { method: "POST", headers: { "Authorization": `Bearer ${process.env.SCENEPOND_API_KEY}`, "Content-Type": "application/json" }, body: JSON.stringify({ "model": "deepseek-v4-pro", "messages": [ { "role": "user", "content": "Hello" } ] }) }); if (!response.ok) throw new Error(`API error: ${response.status} ${await response.text()}`); const result = await response.json(); console.log(result); ``` ### Request parameters - `model` — **Required**; `string`. Use this exact published model ID. - Constraints: `deepseek-v4-pro` - `messages` — **Required**; `object[]`. Send the conversation history in order. - Constraints: `At least one message` ### Fields in messages These fields apply when messages is supplied. A required child does not make its optional parent required. - `messages[].role` — **Required**; `string`. Role of the message author. - Constraints: `system`; `user`; `assistant`; `tool` - `messages[].content` — **Required**; `string | null`. Message text; assistant tool-call messages may use null. - `messages[].name` — **Optional**; `string`. Optional participant name. - `messages[].tool_call_id` — **Conditional**; `string`. Required for a tool reply; match the earlier tool-call ID. - `messages[].tool_calls` — **Optional**; `object[]`. Replay assistant function calls when returning tool results. ### Fields in messages[].tool_calls These fields apply when messages[].tool_calls is supplied. A required child does not make its optional parent required. - `messages[].tool_calls[].id` — **Required**; `string`. Identifier used by the matching tool reply. - `messages[].tool_calls[].type` — **Required**; `string`. Function call type. - Constraints: `function` - `messages[].tool_calls[].function` — **Required**; `object`. Function name and JSON-encoded arguments. ### Fields in messages[].tool_calls[].function These fields apply when messages[].tool_calls[].function is supplied. A required child does not make its optional parent required. - `messages[].tool_calls[].function.name` — **Required**; `string`. Name of the declared function. - `messages[].tool_calls[].function.arguments` — **Required**; `string`. JSON string containing the function arguments. - `messages[].reasoning_content` — **Conditional**; `string`. Replay prior assistant reasoning when continuing a thinking tool-call conversation. - `thinking` — **Optional**; `object`. Enable or disable thinking mode. ### Fields in thinking These fields apply when thinking is supplied. A required child does not make its optional parent required. - `thinking.type` — **Optional**; `string`. Thinking mode switch. - Default: `enabled` - Constraints: `enabled`; `disabled` - `reasoning_effort` — **Optional**; `string`. Choose reasoning effort; none disables thinking. - Default: `high` - Constraints: `none`; `low`; `high`; `max` - `max_tokens` — **Optional**; `integer`. Maximum generated tokens; input and output must also fit the model context. - Constraints: `1–393216` - `stream` — **Optional**; `boolean`. Receive incremental server-sent events. - Default: `false` - `stream_options` — **Optional**; `object`. Streaming options; use together with stream=true. ### Fields in stream_options These fields apply when stream_options is supplied. A required child does not make its optional parent required. - `stream_options.include_usage` — **Optional**; `boolean`. Request token-usage information in the stream. - `temperature` — **Optional**; `number`. Sampling randomness; ignored while thinking is enabled. - Default: `1` - Constraints: `0–2` - `top_p` — **Optional**; `number`. Thinking-mode sampling threshold; ignored in non-thinking mode. - Default: `1` - Constraints: `0 < top_p ≤ 1`; `Thinking mode: values below 0.95 become 0.95` - `stop` — **Optional**; `string | string[]`. Stop generation at any supplied sequence. - Constraints: `Up to 16 sequences` - `response_format` — **Optional**; `object`. Select ordinary text or JSON object output. ### Fields in response_format These fields apply when response_format is supplied. A required child does not make its optional parent required. - `response_format.type` — **Optional**; `string`. Output format. - Default: `text` - Constraints: `text`; `json_object` - `tools` — **Optional**; `object[]`. Declare functions the model may request; your application executes them. ### Fields in tools These fields apply when tools is supplied. A required child does not make its optional parent required. - `tools[].type` — **Required**; `string`. Function tool type. - Constraints: `function` - `tools[].function` — **Required**; `object`. Function definition. ### Fields in tools[].function These fields apply when tools[].function is supplied. A required child does not make its optional parent required. - `tools[].function.name` — **Required**; `string`. Unique function name. - Constraints: `1–128 characters`; `A–Z, a–z, 0–9, underscore or hyphen` - `tools[].function.description` — **Optional**; `string`. Explain when the function should be used. - `tools[].function.parameters` — **Optional**; `object`. JSON Schema for the function arguments; omission means no arguments. - `tool_choice` — **Optional**; `string | object`. Allow, disable, require, or select a function call. - Constraints: `none`; `auto`; `required`; `{"type":"function","function":{"name":"FUNCTION_NAME"}}` - `logprobs` — **Optional**; `boolean`. Return log probabilities for generated text. - `top_logprobs` — **Optional**; `integer`. Number of candidate-token probabilities; requires logprobs=true. - Constraints: `0–20` ### Illustrative responses Response examples show the structure only. IDs, URLs, and values are placeholders. #### Completed chat response ```json { "id": "chatcmpl_example", "object": "chat.completion", "created": 1790812800, "model": "deepseek-v4-pro", "choices": [ { "index": 0, "message": { "role": "assistant", "content": "Hello! How can I help?" }, "finish_reason": "stop" } ], "usage": { "prompt_tokens": 8, "completion_tokens": 9, "total_tokens": 17 } } ``` #### Chat streaming text chunk ```json { "id": "chatcmpl_example", "object": "chat.completion.chunk", "created": 1790812800, "model": "deepseek-v4-pro", "choices": [ { "index": 0, "delta": { "content": "Hello" }, "finish_reason": null } ] } ``` ### Request notes - Use a Scenepond Bearer API key and the Scenepond base URL; no provider key is required. - Thinking is enabled by default. Temperature has no effect in thinking mode; top_p has no effect in non-thinking mode. - When max_tokens is omitted, the provider defaults to 8192 without thinking, 65536 with thinking, or 131072 at max reasoning effort. - JSON object output also needs an instruction to produce JSON. Check finish_reason before treating truncated output as complete JSON. - Required or named tool_choice needs thinking disabled. Validate function arguments before executing a tool. - Preserve assistant tool_calls, their reasoning_content, and matching tool replies across thinking tool-call turns. - Chat streaming ends with [DONE]. The provider includes final token usage; the gateway may normalize usage-chunk delivery. - The gateway removes stream_options when stream is false and may request usage automatically on supported channels. - frequency_penalty and presence_penalty no longer affect native DeepSeek output. Do not rely on seed, n, or max_completion_tokens as supported DeepSeek controls. - The provider documents user_id, but the current gateway Chat DTO does not preserve that field. Extra undocumented fields are not guaranteed to reach the provider. - Assistant prefix completion and strict tool schemas are provider beta features; their beta routing is not verified by this standard Chat endpoint. - This model reference covers text input. Image input is documented for DeepSeek Flash; do not infer it for DeepSeek V4 Pro. ## Responses `POST /v1/responses` ### Minimum request #### cURL ```bash curl --fail-with-body -X POST "https://scenepond-api-production.up.railway.app/v1/responses" \ -H "Authorization: Bearer $SCENEPOND_API_KEY" \ -H "Content-Type: application/json" \ --data-binary @- <<'JSON' { "model": "deepseek-v4-pro", "input": "Hello" } JSON ``` #### Python ```python import os import json from urllib.parse import quote from urllib.request import Request, urlopen payload = json.loads("{\n \"model\": \"deepseek-v4-pro\",\n \"input\": \"Hello\"\n}") request = Request( "https://scenepond-api-production.up.railway.app/v1/responses", headers={ "Authorization": "Bearer " + os.environ["SCENEPOND_API_KEY"], "Content-Type": "application/json", }, data=json.dumps(payload).encode("utf-8"), method="POST", ) with urlopen(request) as response: result = json.load(response) print(json.dumps(result, indent=2)) ``` #### JavaScript ```javascript const response = await fetch("https://scenepond-api-production.up.railway.app/v1/responses", { method: "POST", headers: { "Authorization": `Bearer ${process.env.SCENEPOND_API_KEY}`, "Content-Type": "application/json" }, body: JSON.stringify({ "model": "deepseek-v4-pro", "input": "Hello" }) }); if (!response.ok) throw new Error(`API error: ${response.status} ${await response.text()}`); const result = await response.json(); console.log(result); ``` ### Request parameters - `model` — **Required**; `string`. Use this exact published model ID. - Constraints: `deepseek-v4-pro` - `input` — **Required**; `string | object[]`. Send text or the complete input-item history; the gateway requires input. ### Fields in input These fields apply when input is supplied. A required child does not make its optional parent required. - `input[].type` — **Conditional**; `string`. Input item type; message type may be omitted when role is supplied. - Constraints: `message`; `function_call`; `function_call_output`; `reasoning`; `custom_tool_call`; `custom_tool_call_output` - `input[].role` — **Conditional**; `string`. Message author; developer is treated as user by DeepSeek. - Required for message input items. - Constraints: `system`; `developer`; `user`; `assistant` - `input[].content` — **Conditional**; `string | object[]`. Text content or typed content parts for a message or reasoning item. ### Fields in input[].content These fields apply when input[].content is supplied. A required child does not make its optional parent required. - `input[].content[].type` — **Required**; `string`. Content part type. - Constraints: `input_text`; `output_text`; `reasoning_text` - `input[].content[].text` — **Conditional**; `string`. Text for a text or reasoning part. - `input[].call_id` — **Conditional**; `string`. Pair each function or custom tool call with its result using the same call ID. - `input[].name` — **Conditional**; `string`. Function name for a function_call item. - `input[].arguments` — **Conditional**; `string`. JSON-encoded arguments for a function_call item. - `input[].output` — **Conditional**; `string | object[]`. Result content for a function_call_output or custom_tool_call_output item. - `instructions` — **Optional**; `string`. Optional system instruction; input remains required by this gateway. - `reasoning` — **Optional**; `object`. Configure thinking effort. ### Fields in reasoning These fields apply when reasoning is supplied. A required child does not make its optional parent required. - `reasoning.effort` — **Optional**; `string`. Choose reasoning effort; none disables thinking. - Default: `high` - Constraints: `none`; `low`; `high`; `max` - `max_output_tokens` — **Optional**; `integer`. Limit visible output and reasoning tokens together. - Constraints: `Positive integer; model context and output limits still apply` - `stream` — **Optional**; `boolean`. Receive semantic server-sent events instead of one JSON response. - Default: `false` - `temperature` — **Optional**; `number`. Sampling randomness; ignored while thinking is enabled. - Default: `1` - Constraints: `0–2` - `top_p` — **Optional**; `number`. Thinking-mode sampling threshold; ignored in non-thinking mode. - Default: `1` - Constraints: `0 < top_p ≤ 1`; `Thinking mode: values below 0.95 become 0.95` - `text` — **Optional**; `object`. Configure text output format. ### Fields in text These fields apply when text is supplied. A required child does not make its optional parent required. - `text.format` — **Optional**; `object`. Plain text, JSON object, or JSON Schema output. ### Fields in text.format These fields apply when text.format is supplied. A required child does not make its optional parent required. - `text.format.type` — **Optional**; `string`. Output format. - Default: `text` - Constraints: `text`; `json_object`; `json_schema` - `text.format.name` — **Conditional**; `string`. Required when format.type is json_schema. - `text.format.schema` — **Conditional**; `object`. Required JSON Schema when format.type is json_schema. - `tools` — **Optional**; `object[]`. Declare function tools; your application executes the returned calls. ### Fields in tools These fields apply when tools is supplied. A required child does not make its optional parent required. - `tools[].type` — **Required**; `string`. Function tool type. - Constraints: `function` - `tools[].name` — **Required**; `string`. Unique function name. - Constraints: `1–128 characters`; `A–Z, a–z, 0–9, underscore or hyphen` - `tools[].description` — **Optional**; `string`. Explain when the function should be used. - `tools[].parameters` — **Optional**; `object`. JSON Schema for the function arguments; omission means no arguments. - `tool_choice` — **Optional**; `string | object`. Allow, disable, require, or select a function call. - Constraints: `none`; `auto`; `required`; `{"type":"function","name":"FUNCTION_NAME"}` - `top_logprobs` — **Optional**; `integer`. Number of candidate-token log probabilities. - Constraints: `0–20` - `user` — **Optional**; `string`. Optional pseudonymous end-user identifier; never include private information. - Constraints: `Up to 512 characters`; `A–Z, a–z, 0–9, underscore or hyphen` ### Illustrative responses Response examples show the structure only. IDs, URLs, and values are placeholders. #### Completed Responses result ```json { "id": "response_example", "object": "response", "created_at": 1790812800, "status": "completed", "model": "deepseek-v4-pro", "output": [ { "id": "message_example", "type": "message", "role": "assistant", "status": "completed", "content": [ { "type": "output_text", "text": "Hello! How can I help?" } ] } ], "usage": { "input_tokens": 8, "output_tokens": 9, "total_tokens": 17 } } ``` #### Responses streaming text event ```json { "type": "response.output_text.delta", "sequence_number": 5, "item_id": "message_example", "output_index": 0, "content_index": 0, "delta": "Hello" } ``` ### Request notes - Use a Scenepond Bearer API key and the Scenepond base URL; no provider key is required. - Native DeepSeek Responses supports ordinary JSON and stream=true. It does not use the Fal background-task lifecycle. - DeepSeek Responses is stateless: send full history on each call. Do not use previous_response_id, conversation, background tasks, or GET response polling. - The gateway requires input even though the provider also describes instructions-only requests. - Streaming ends with response.completed, response.incomplete, or response.failed; it has no [DONE] sentinel. - Function tools use top-level name and parameters. Chat-style nested function definitions are a different schema. - The provider additionally supports the custom tool named apply_patch; other custom names are rejected, and built-in web_search, file_search, code_interpreter, computer_use, and mcp tools are ignored. - reasoning.summary and text.verbosity have no effect. parallel_tool_calls and max_tool_calls are ignored; parallel function calls remain enabled. - store, metadata, include, prompt, truncation, service_tier, safety_identifier, prompt-cache controls, context_management, and stream_options are not supported by native DeepSeek Responses. - The gateway Chat and Responses DTOs preserve only their recognized fields during ordinary relay. An OpenAI-compatible field is not automatically a supported DeepSeek feature. - This model reference covers text input. Image input is documented for DeepSeek Flash; do not infer it for DeepSeek V4 Pro. ## Anthropic Messages `POST /v1/messages` ### Minimum request #### cURL ```bash curl --fail-with-body -X POST "https://scenepond-api-production.up.railway.app/v1/messages" \ -H "Authorization: Bearer $SCENEPOND_API_KEY" \ -H "Content-Type: application/json" \ --data-binary @- <<'JSON' { "model": "deepseek-v4-pro", "max_tokens": 1024, "messages": [ { "role": "user", "content": "Hello" } ] } JSON ``` #### Python ```python import os import json from urllib.parse import quote from urllib.request import Request, urlopen payload = json.loads("{\n \"model\": \"deepseek-v4-pro\",\n \"max_tokens\": 1024,\n \"messages\": [\n {\n \"role\": \"user\",\n \"content\": \"Hello\"\n }\n ]\n}") request = Request( "https://scenepond-api-production.up.railway.app/v1/messages", headers={ "Authorization": "Bearer " + os.environ["SCENEPOND_API_KEY"], "Content-Type": "application/json", }, data=json.dumps(payload).encode("utf-8"), method="POST", ) with urlopen(request) as response: result = json.load(response) print(json.dumps(result, indent=2)) ``` #### JavaScript ```javascript const response = await fetch("https://scenepond-api-production.up.railway.app/v1/messages", { method: "POST", headers: { "Authorization": `Bearer ${process.env.SCENEPOND_API_KEY}`, "Content-Type": "application/json" }, body: JSON.stringify({ "model": "deepseek-v4-pro", "max_tokens": 1024, "messages": [ { "role": "user", "content": "Hello" } ] }) }); if (!response.ok) throw new Error(`API error: ${response.status} ${await response.text()}`); const result = await response.json(); console.log(result); ``` ### Request parameters - `model` — **Required**; `string`. Use this exact published model ID. - Constraints: `deepseek-v4-pro` - `messages` — **Required**; `object[]`. Send the conversation history in order; put system instructions in system. - Constraints: `At least one message` ### Fields in messages These fields apply when messages is supplied. A required child does not make its optional parent required. - `messages[].role` — **Required**; `string`. Role of the message author. - Constraints: `user`; `assistant` - `messages[].content` — **Required**; `string | object[]`. Message text or typed content blocks. ### Fields in messages[].content These fields apply when messages[].content is supplied. A required child does not make its optional parent required. - `messages[].content[].type` — **Required**; `string`. Content block type. - Constraints: `text`; `thinking`; `tool_use`; `tool_result` - `messages[].content[].text` — **Conditional**; `string`. Required for a text block. - `messages[].content[].thinking` — **Conditional**; `string`. Reasoning text when replaying an assistant thinking block. - `messages[].content[].id` — **Conditional**; `string`. Required for a tool_use block. - `messages[].content[].name` — **Conditional**; `string`. Declared function name for a tool_use block. - Required for a tool_use block. - `messages[].content[].input` — **Conditional**; `object`. Function arguments for a tool_use block. - Required for a tool_use block. - `messages[].content[].tool_use_id` — **Conditional**; `string`. Required for a tool_result block; match the original tool-use ID. - `messages[].content[].content` — **Optional**; `string | object[]`. Tool result text or supported content blocks. - `max_tokens` — **Optional**; `integer`. SDKs expect an output limit. The gateway supplies a configured default if omitted or zero; set a positive value explicitly. - Constraints: `Positive integer; model context and output limits still apply` - `system` — **Optional**; `string | object[]`. System instruction text or text blocks. ### Fields in system These fields apply when system is supplied. A required child does not make its optional parent required. - `system[].type` — **Required**; `string`. System content block type. - Constraints: `text` - `system[].text` — **Required**; `string`. System instruction. - `stop_sequences` — **Optional**; `string[]`. Stop generation at a supplied sequence. - `stream` — **Optional**; `boolean`. Receive Anthropic-style server-sent events. - Default: `false` - `temperature` — **Optional**; `number`. Sampling randomness; ignored while thinking is enabled. - Default: `1` - Constraints: `0–2` - `top_p` — **Optional**; `number`. Thinking-mode sampling threshold; ignored in non-thinking mode. - Default: `1` - Constraints: `0 < top_p ≤ 1`; `Thinking mode: values below 0.95 become 0.95` - `thinking` — **Optional**; `object`. Enable or disable thinking mode. ### Fields in thinking These fields apply when thinking is supplied. A required child does not make its optional parent required. - `thinking.type` — **Optional**; `string`. Thinking mode switch. - Default: `enabled` - Constraints: `enabled`; `disabled` - `output_config` — **Optional**; `object`. Only reasoning effort is supported from output_config. ### Fields in output_config These fields apply when output_config is supplied. A required child does not make its optional parent required. - `output_config.effort` — **Optional**; `string`. Thinking effort. - Default: `high` - Constraints: `low`; `high`; `max` - `tools` — **Optional**; `object[]`. Declare client-executed function tools. ### Fields in tools These fields apply when tools is supplied. A required child does not make its optional parent required. - `tools[].name` — **Required**; `string`. Unique function name. - `tools[].description` — **Optional**; `string`. Explain when the function should be used. - `tools[].input_schema` — **Required**; `object`. JSON Schema for the tool input. - `tool_choice` — **Optional**; `object`. Configure tool selection using the Anthropic schema. ### Fields in tool_choice These fields apply when tool_choice is supplied. A required child does not make its optional parent required. - `tool_choice.type` — **Required**; `string`. Tool selection mode. - Constraints: `none`; `auto`; `any`; `tool` - `tool_choice.name` — **Conditional**; `string`. Required when tool_choice.type is tool. - `metadata` — **Optional**; `object`. Only the pseudonymous user_id field is supported. ### Fields in metadata These fields apply when metadata is supplied. A required child does not make its optional parent required. - `metadata.user_id` — **Optional**; `string`. Optional pseudonymous end-user identifier; never include private information. - Constraints: `Up to 512 characters`; `A–Z, a–z, 0–9, underscore or hyphen` ### Illustrative responses Response examples show the structure only. IDs, URLs, and values are placeholders. #### Completed Anthropic-compatible message ```json { "id": "message_example", "type": "message", "role": "assistant", "model": "deepseek-v4-pro", "content": [ { "type": "text", "text": "Hello! How can I help?" } ], "stop_reason": "end_turn", "stop_sequence": null, "usage": { "input_tokens": 8, "output_tokens": 9 } } ``` #### Anthropic streaming text event ```json { "type": "content_block_delta", "index": 0, "delta": { "type": "text_delta", "text": "Hello" } } ``` ### Request notes - Use the Scenepond /v1/messages endpoint with a Scenepond Bearer API key. Provider credentials and provider URLs are unnecessary. - The gateway checks model and nonempty messages. Its native DeepSeek adaptor also supplies max_tokens when omitted or zero; SDK clients commonly require that value, so the example sets it explicitly. - This is DeepSeek through the Anthropic-compatible wire format. Claude-specific capability assumptions do not carry over. - thinking.budget_tokens, top_k, container, mcp_servers, service_tier, cache_control, and tool_choice.disable_parallel_tool_use have no effect in native DeepSeek compatibility. - Only output_config.effort and metadata.user_id are supported from those objects; other members are ignored. - Document, redacted_thinking, code_execution_tool_result, mcp_tool_use, mcp_tool_result, and container_upload blocks are unsupported. Do not infer Files API support from this model endpoint. - Return tool_result blocks with matching tool_use_id after executing a requested function. Validate tool inputs in your application. - Anthropic streaming uses named events and finishes with message_stop; it is not Fal task polling. - This model reference covers text input. Image input is documented for DeepSeek Flash; do not infer it for DeepSeek V4 Pro. ## Sources - [DeepSeek Chat Completions API](https://api-docs.deepseek.com/api/create-chat-completion/) - [DeepSeek Responses API](https://api-docs.deepseek.com/api/create-response/) - [DeepSeek thinking mode](https://api-docs.deepseek.com/guides/thinking_mode/) - [DeepSeek Responses compatibility](https://api-docs.deepseek.com/guides/responses_api/) - [DeepSeek Anthropic compatibility](https://api-docs.deepseek.com/guides/anthropic_api/) - [DeepSeek vision input](https://api-docs.deepseek.com/guides/vision/)