You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@seatunnel.apache.org by li...@apache.org on 2026/08/11 14:42:18 UTC

(seatunnel) branch dev updated: [Feature][Connector-V2] Add NATS JetStream sink connector (#11460)

This is an automated email from the ASF dual-hosted git repository.

davidzollo pushed a commit to branch dev
in repository https://gitbox.apache.org/repos/asf/seatunnel.git


The following commit(s) were added to refs/heads/dev by this push:
     new a6beccf8bb [Feature][Connector-V2] Add NATS JetStream sink connector (#11460)
a6beccf8bb is described below

commit a6beccf8bbcbb34dee3f20aabd00315d036fa8a5
Author: I Putu Ariyasa <ru...@gmail.com>
AuthorDate: Tue Aug 11 21:42:12 2026 +0700

    [Feature][Connector-V2] Add NATS JetStream sink connector (#11460)
---
 .github/workflows/labeler/label-scope-conf.yml     |  10 +
 config/plugin_config                               |   1 +
 .../changelog/connector-nats-jetstream.md          |  26 ++
 docs/en/connectors/sink/NatsJetStream.md           | 340 +++++++++++++++++
 .../changelog/connector-nats-jetstream.md          |  26 ++
 docs/zh/connectors/sink/NatsJetStream.md           | 340 +++++++++++++++++
 plugin-mapping.properties                          |   1 +
 .../connector-nats-jetstream/pom.xml               |  56 +++
 .../config/NatsJetStreamMessageFormat.java         |  23 ++
 .../config/NatsJetStreamSinkOptions.java           | 111 ++++++
 .../exception/NatsJetStreamConnectorException.java |  34 ++
 .../sink/NatsJetStreamRequestSerializer.java       | 165 +++++++++
 .../natsjetstream/sink/NatsJetStreamSink.java      |  59 +++
 .../sink/NatsJetStreamSinkFactory.java             |  61 ++++
 .../sink/NatsJetStreamSinkValidator.java           | 249 +++++++++++++
 .../sink/NatsJetStreamSinkWriter.java              | 294 +++++++++++++++
 .../sink/NatsJetStreamRequestSerializerTest.java   | 267 ++++++++++++++
 .../sink/NatsJetStreamSinkFactoryTest.java         | 350 ++++++++++++++++++
 .../sink/NatsJetStreamSinkWriterTest.java          | 322 +++++++++++++++++
 .../seatunnel/natsjetstream/sink/TestContext.java  |  40 ++
 .../natsjetstream/sink/TestWriterResources.java    |  94 +++++
 seatunnel-connectors-v2/pom.xml                    |   1 +
 seatunnel-dist/pom.xml                             |   7 +
 seatunnel-dist/release-docs/LICENSE                |   9 +-
 seatunnel-dist/release-docs/NOTICE                 |   4 +
 .../licenses/LICENSE-bcprov-lts8on.txt             |  21 ++
 .../release-docs/licenses/LICENSE-jnats.txt        |   1 +
 .../release-docs/licenses/LICENSE-jspecify.txt     |   1 +
 .../connector-nats-jetstream-e2e/pom.xml           |  67 ++++
 .../connector/natsjetstream/NatsJetStreamIT.java   | 402 +++++++++++++++++++++
 .../resources/fake_to_nats_jetstream_json.conf     |  70 ++++
 .../resources/fake_to_nats_jetstream_native.conf   |  90 +++++
 .../fake_to_nats_jetstream_native_defaults.conf    |  66 ++++
 seatunnel-e2e/seatunnel-connector-v2-e2e/pom.xml   |   1 +
 34 files changed, 3607 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/labeler/label-scope-conf.yml b/.github/workflows/labeler/label-scope-conf.yml
index 8e7328c3bf..77c2bc875e 100644
--- a/.github/workflows/labeler/label-scope-conf.yml
+++ b/.github/workflows/labeler/label-scope-conf.yml
@@ -360,3 +360,13 @@ bigquery:
       - changed-files:
           - any-glob-to-any-file: seatunnel-connectors-v2/connector-bigquery/**
           - all-globs-to-all-files: '!seatunnel-connectors-v2/connector-!(bigquery)/**'
+
+nats-jetstream:
+  - all:
+      - changed-files:
+          - any-glob-to-any-file:
+              - seatunnel-connectors-v2/connector-nats-jetstream/**
+              - seatunnel-e2e/seatunnel-connector-v2-e2e/connector-nats-jetstream-e2e/**
+          - all-globs-to-all-files:
+              - '!seatunnel-connectors-v2/connector-!(nats-jetstream)/**'
+              - '!seatunnel-e2e/seatunnel-connector-v2-e2e/connector-!(nats-jetstream)-e2e/**'
diff --git a/config/plugin_config b/config/plugin_config
index 3509930ac4..f4032272de 100644
--- a/config/plugin_config
+++ b/config/plugin_config
@@ -105,3 +105,4 @@ connector-hugegraph
 connector-lance
 connector-mqtt
 connector-bigquery
+connector-nats-jetstream
diff --git a/docs/en/connectors/changelog/connector-nats-jetstream.md b/docs/en/connectors/changelog/connector-nats-jetstream.md
new file mode 100644
index 0000000000..19cb0e4072
--- /dev/null
+++ b/docs/en/connectors/changelog/connector-nats-jetstream.md
@@ -0,0 +1,26 @@
+<!--
+
+    Licensed to the Apache Software Foundation (ASF) under one or more
+    contributor license agreements.  See the NOTICE file distributed with
+    this work for additional information regarding copyright ownership.
+    The ASF licenses this file to You under the Apache License, Version 2.0
+    (the "License"); you may not use this file except in compliance with
+    the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+
+-->
+
+# Changelog
+
+## next version
+
+### Sink
+
+- Add NATS JetStream Sink Connector
diff --git a/docs/en/connectors/sink/NatsJetStream.md b/docs/en/connectors/sink/NatsJetStream.md
new file mode 100644
index 0000000000..160508b0dc
--- /dev/null
+++ b/docs/en/connectors/sink/NatsJetStream.md
@@ -0,0 +1,340 @@
+import ChangeLog from '../changelog/connector-nats-jetstream.md';
+
+# NatsJetStream
+
+> NATS JetStream sink connector
+
+## Description
+
+NatsJetStream is a **JetStream sink**, not a core NATS publish connector. It writes SeaTunnel rows to a JetStream-enabled NATS Server by using the `io.nats:jnats` client and waiting for the synchronous JetStream publish acknowledgement for each record.
+
+The current implementation targets JetStream-enabled **NATS Server 2.x** with the `jnats` **2.24.0** client used by this connector. The connector documentation only claims compatibility proven by the current implementation and E2E coverage.
+
+The sink does **not** create streams or manage JetStream resources. You must pre-provision a JetStream stream and bind it to the subject, or subject pattern, used by the sink.
+
+## Key features
+
+- [ ] [exactly-once](../../introduction/concepts/connector-v2-features.md)
+- [ ] [timer flush](../../introduction/concepts/connector-v2-features.md)
+
+:::caution Delivery semantics
+
+This sink provides **at-least-once** delivery.
+
+A successful synchronous JetStream publish acknowledgement means JetStream accepted that publish request, but it does **not** prove exactly-once delivery across retries, task restarts, failover, or ambiguous acknowledgement loss.
+
+Duplicates can still happen when SeaTunnel retries after a publish succeeded but the acknowledgement was lost, delayed, or surfaced ambiguously to the writer.
+
+Native-mode message IDs are only a **broker-side duplicate-mitigation hint**. JetStream duplicate suppression works only when:
+
+1. the target stream is configured with a duplicate window, and
+2. the sink writes stable message IDs.
+
+Even with that setup, the connector must still be treated as **at-least-once**.
+
+:::
+
+## Supported Engines
+
+> SeaTunnel Zeta<br/>
+> Flink<br/>
+> Spark<br/>
+
+## Connector contract
+
+- Scope: sink only; no NATS source support is included.
+- Compatibility target: JetStream-enabled NATS Server 2.x with `io.nats:jnats:2.24.0`.
+- Stream lifecycle: publish-only. The connector does not create, update, or delete streams, consumers, or subjects.
+- Delivery guarantee: writer-only at-least-once.
+- Duplicate handling: duplicates are possible on retry, restart, checkpoint recovery, or ambiguous acknowledgement loss.
+- JSON mode: one configured subject, JSON payload, no per-record headers or message ID.
+- Native mode: maps row fields to `subject`, `id`, `headers`, and `data`; `data` is required and must be `bytes`.
+- Row kinds: all SeaTunnel row kinds are published as ordinary sink messages; no CDC-aware update/delete behavior is provided.
+- Authentication: use either no credentials, `username` + `password`, or `token`; `token` is mutually exclusive with `username` / `password`.
+- Initial limitations: synchronous per-record publish only; batching and connector-managed retry controls are out of scope.
+- Non-goals: stream administration, exactly-once, source support, schema evolution handling beyond incoming rows, and formats beyond documented JSON/native mode.
+
+## Broker setup
+
+Before running a SeaTunnel job:
+
+1. Start a JetStream-enabled NATS Server.
+2. Create the target stream yourself.
+3. Bind the stream to the configured subject or subject pattern.
+4. Ensure the subject used by JSON mode or the final subject produced by native mode is covered by that stream binding.
+
+If the stream does not exist, JetStream is disabled, or the subject is not bound to a stream, the sink can fail when the first publish reaches JetStream.
+
+## Options
+
+| name | type | required | default value |
+|------|------|----------|---------------|
+| url | string | yes | - |
+| username | string | no | - |
+| password | string | no | - |
+| token | string | no | - |
+| subject | string | conditional | - |
+| format | enum (`json`, `native`) | no | json |
+| native_format_fields | map<string,string> | no | `{id:id, subject:subject, headers:headers, data:data}` |
+| include_row_kind_header | boolean | no | true |
+| common-options | - | no | - |
+
+### Authentication rules
+
+- Configure `username` and `password` together, or configure `token`.
+- Do not configure `token` together with `username` / `password`.
+- Treat `password` and `token` as sensitive options and do not expose them in shared configs or logs.
+
+### subject [string]
+
+- Required in `json` format.
+- Optional in `native` format only when `native_format_fields.subject` is mapped to a nonblank row field.
+- In `native` format, it is used as the fallback subject when the mapped subject field is `null`, empty, or blank.
+
+### native_format_fields [map<string,string>]
+
+Used only when `format = "native"`.
+
+Supported mapping keys:
+
+- `data`: required mapping, must point to a `bytes` field
+- `subject`: optional mapping, must point to a `string` field when present in the schema
+- `id`: optional mapping, must point to a `string` field when present in the schema
+- `headers`: optional mapping, must point to a `map<string,string>` field when present in the schema
+
+Unsupported mapping keys are rejected.
+
+When an optional mapping (`subject`, `id`, `headers`) points to a field that does not exist in the input schema, the connector silently skips that mapping. For example, with the default mapping `{id:id, subject:subject, headers:headers, data:data}`, a schema that only contains a `data` field will still be accepted; `id`, `subject`, and `headers` are simply not set on the published message.
+
+### include_row_kind_header [boolean]
+
+Used only when `format = "native"`.
+
+- Default is `true`.
+- When enabled, the connector adds JetStream header `x-seatunnel-row-kind` with the SeaTunnel row kind name.
+- When disabled, the connector does not add that generated header.
+- Mapped `headers` are still written normally.
+
+### common options
+
+Sink plugin common parameters, please refer to [Sink Common Options](../common-options/sink-common-options.md) for details.
+
+## Data contract
+
+### JSON mode
+
+When `format = "json"`:
+
+- every incoming row is serialized as one JSON payload;
+- the payload is written to the fixed sink `subject`;
+- no per-record headers or message ID are produced by the connector, and row kind metadata is not added to the JSON payload.
+
+### Native mode
+
+When `format = "native"`, each row is mapped to a JetStream publish request:
+
+- `data` -> message payload, required, `bytes`
+- `subject` -> per-record subject, optional, `string`
+- `id` -> JetStream message ID, optional, `string`
+- `headers` -> JetStream headers, optional, `map<string,string>`
+- when `include_row_kind_header = true`, the connector also adds JetStream header `x-seatunnel-row-kind` with the SeaTunnel row kind name
+
+Final subject resolution order:
+
+1. use the mapped native `subject` field when it is nonblank;
+2. otherwise use the sink `subject` option;
+3. if neither exists, validation fails before the writer starts.
+
+If native `id` is `null`, empty, or blank, the message is published without a JetStream message ID.
+
+If native `headers` is `null`, the connector sends only the generated `x-seatunnel-row-kind` header when `include_row_kind_header = true`.
+
+## Row kind handling
+
+The sink accepts all SeaTunnel row kinds.
+
+It does not interpret `INSERT`, `UPDATE_BEFORE`, `UPDATE_AFTER`, or `DELETE` as CDC operations. Each row is published as an ordinary message according to the configured JSON or native format.
+
+In native format, the connector can expose the row kind as JetStream header `x-seatunnel-row-kind` when `include_row_kind_header = true`. JSON format does not include row kind metadata in the payload.
+
+## Examples
+
+### Minimal JSON example
+
+```hocon
+env {
+  parallelism = 1
+  job.mode = "BATCH"
+}
+
+source {
+  FakeSource {
+    rows = [
+      {
+        kind = INSERT
+        fields = {
+          id = 101
+          name = "alice"
+          score = 9.5
+        }
+      }
+    ]
+    schema = {
+      fields {
+        id = int
+        name = string
+        score = double
+      }
+    }
+    plugin_output = "json_fake"
+  }
+}
+
+sink {
+  NatsJetStream {
+    plugin_input = "json_fake"
+    url = "nats://127.0.0.1:4222"
+    subject = "orders.json"
+    format = "json"
+  }
+}
+```
+
+Produced payload:
+
+```json
+{"id":101,"name":"alice","score":9.5}
+```
+
+All rows are published to the fixed subject `orders.json`.
+
+### Native-mode example
+
+```hocon
+env {
+  parallelism = 1
+  job.mode = "BATCH"
+}
+
+source {
+  FakeSource {
+    rows = [
+      {
+        kind = INSERT
+        fields = {
+          dynamic_subject = "events.native.alpha"
+          message_id = "msg-1"
+          attributes = {
+            tenant = "acme"
+            trace = "trace-1"
+          }
+          payload = [1, 35, -1]
+        }
+      },
+      {
+        kind = INSERT
+        fields = {
+          dynamic_subject = "events.native.beta"
+          message_id = "msg-2"
+          attributes = {
+            tenant = "beta"
+            trace = "trace-2"
+          }
+          payload = [112, 97, 121, 108, 111, 97, 100, 45, 50]
+        }
+      }
+    ]
+    schema = {
+      fields {
+        dynamic_subject = string
+        message_id = string
+        attributes = "map<string,string>"
+        payload = bytes
+      }
+    }
+    plugin_output = "native_fake"
+  }
+}
+
+sink {
+  NatsJetStream {
+    plugin_input = "native_fake"
+    url = "nats://127.0.0.1:4222"
+    subject = "events.native.default"
+    format = "native"
+    native_format_fields = {
+      subject = dynamic_subject
+      id = message_id
+      headers = attributes
+      data = payload
+    }
+  }
+}
+```
+
+Native mapping result for the first row:
+
+- subject: `events.native.alpha`
+- message ID: `msg-1`
+- headers: `tenant=acme`, `trace=trace-1`
+- payload bytes: `[1, 35, -1]`
+
+If `dynamic_subject` is blank or `null`, the connector falls back to `subject = "events.native.default"`.
+
+### Native mode with explicit default field mapping
+
+When the input schema already contains `subject`, `id`, `headers`, and `data`, you can use the default mapping values below.
+
+```hocon
+native_format_fields = {
+  subject = subject
+  id = id
+  headers = headers
+  data = data
+}
+```
+
+`native_format_fields` still needs to provide the `data` mapping in native mode.
+
+Input schema contract:
+
+```text
+subject : string
+id      : string
+headers : map<string,string>
+data    : bytes
+```
+
+## Errors and operational notes
+
+- Connection failures fail writer startup.
+- Publish failures fail the task with the target subject in the error message.
+- Missing stream bindings, wrong subjects, or JetStream API errors can appear on the first publish.
+- The writer uses synchronous per-record publish calls, so throughput depends on JetStream acknowledgement latency.
+
+## Unsupported features and limitations
+
+- No exactly-once guarantee.
+- No core NATS publish mode without JetStream.
+- No stream creation, update, or deletion.
+- No connector-managed deduplication window configuration.
+- No native payload conversion from non-`bytes` columns.
+- No CDC-aware update/delete semantics based on row kind.
+
+## FAQ
+
+### Is this a core NATS publisher?
+
+No. It publishes through the JetStream API and expects JetStream-enabled server-side resources.
+
+### Can the connector create the stream automatically?
+
+No. The stream must be created and bound to the publish subject before the job starts.
+
+### Can message IDs make delivery exactly-once?
+
+No. Message IDs only help JetStream duplicate suppression when the target stream has a duplicate window and producers resend the same stable ID.
+
+## Changelog
+
+<ChangeLog />
diff --git a/docs/zh/connectors/changelog/connector-nats-jetstream.md b/docs/zh/connectors/changelog/connector-nats-jetstream.md
new file mode 100644
index 0000000000..19cb0e4072
--- /dev/null
+++ b/docs/zh/connectors/changelog/connector-nats-jetstream.md
@@ -0,0 +1,26 @@
+<!--
+
+    Licensed to the Apache Software Foundation (ASF) under one or more
+    contributor license agreements.  See the NOTICE file distributed with
+    this work for additional information regarding copyright ownership.
+    The ASF licenses this file to You under the Apache License, Version 2.0
+    (the "License"); you may not use this file except in compliance with
+    the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+
+-->
+
+# Changelog
+
+## next version
+
+### Sink
+
+- Add NATS JetStream Sink Connector
diff --git a/docs/zh/connectors/sink/NatsJetStream.md b/docs/zh/connectors/sink/NatsJetStream.md
new file mode 100644
index 0000000000..2bf3a86094
--- /dev/null
+++ b/docs/zh/connectors/sink/NatsJetStream.md
@@ -0,0 +1,340 @@
+import ChangeLog from '../changelog/connector-nats-jetstream.md';
+
+# NatsJetStream
+
+> NATS JetStream Sink 连接器
+
+## 描述
+
+NatsJetStream 是一个 **JetStream sink**,不是 core NATS publish 连接器。它使用 `io.nats:jnats` 客户端把 SeaTunnel 行数据写入启用了 JetStream 的 NATS Server,并且对每条记录等待同步的 JetStream publish acknowledgement。
+
+当前实现面向启用了 JetStream 的 **NATS Server 2.x**,以及该连接器当前使用的 `jnats` **2.24.0** 客户端版本。本文档只声明当前实现和 E2E 测试已经证明的兼容范围。
+
+该 Sink **不会**创建 stream,也不会管理 JetStream 资源。你必须预先创建目标 JetStream stream,并把它绑定到该 Sink 使用的 subject 或 subject pattern。
+
+## 主要特性
+
+- [ ] [精确一次](../../introduction/concepts/connector-v2-features.md)
+- [ ] [定时刷新](../../introduction/concepts/connector-v2-features.md)
+
+:::caution 投递语义
+
+该 Sink 提供 **至少一次** 投递。
+
+同步的 JetStream publish acknowledgement 只能说明 JetStream 已经接受了这次 publish 请求,但**不能**证明在重试、任务重启、故障切换或 acknowledgement 歧义丢失场景下实现 exactly-once。
+
+如果 SeaTunnel 在消息实际上已写入成功后,因为 acknowledgement 丢失、延迟或返回结果不明确而触发重试,仍然可能产生重复消息。
+
+native 模式中的 message ID 只能作为 **broker 侧的重复缓解提示**。JetStream 的重复抑制只有在以下两个条件同时满足时才会生效:
+
+1. 目标 stream 配置了 duplicate window;
+2. Sink 写出了稳定的 message ID。
+
+即使满足以上条件,这个连接器仍然只能按 **至少一次** 理解。
+
+:::
+
+## 支持引擎
+
+> SeaTunnel Zeta<br/>
+> Flink<br/>
+> Spark<br/>
+
+## Connector contract
+
+- 范围:仅支持 sink;本次贡献不包含 NATS source。
+- 兼容性目标:启用 JetStream 的 NATS Server 2.x,客户端版本为 `io.nats:jnats:2.24.0`。
+- Stream 生命周期:仅发布。连接器不会创建、更新或删除 stream、consumer 或 subject。
+- 交付语义:writer-only at-least-once。
+- 重复消息:在重试、重启、checkpoint 恢复或 acknowledgement 模糊丢失时,可能产生重复。
+- JSON 模式:单个已配置 subject、JSON payload,不支持逐条消息 headers 或 message ID。
+- Native 模式:把行字段映射为 `subject`、`id`、`headers` 和 `data`;其中 `data` 必填且必须是 `bytes`。
+- Row kind:所有 SeaTunnel row kind 都作为普通 sink 消息发布;不提供 CDC 感知的 update/delete 语义。
+- 认证:只能使用无认证、`username` + `password`,或单独 `token`;`token` 与 `username` / `password` 互斥。
+- 初始限制:仅支持同步逐条发布;batching 和连接器自管 retry 不在范围内。
+- 非目标:stream 管理、exactly-once、source 支持、超出输入行模式的 schema evolution,以及文档之外的格式。
+
+## Broker 准备
+
+运行 SeaTunnel 作业前,请先完成以下准备:
+
+1. 启动启用了 JetStream 的 NATS Server。
+2. 自行创建目标 stream。
+3. 把该 stream 绑定到配置的 subject 或 subject pattern。
+4. 确保 JSON 模式使用的 subject,或 native 模式最终解析出的 subject,已经被该 stream 覆盖。
+
+如果 stream 不存在、JetStream 未启用、或者 subject 没有绑定到 stream,Sink 可能会在第一条消息 publish 到 JetStream 时失败。
+
+## 选项
+
+| 名称 | 类型 | 是否必填 | 默认值 |
+|------|------|----------|--------|
+| url | string | 是 | - |
+| username | string | 否 | - |
+| password | string | 否 | - |
+| token | string | 否 | - |
+| subject | string | 条件必填 | - |
+| format | 枚举(`json`、`native`) | 否 | json |
+| native_format_fields | map<string,string> | 否 | `{id:id, subject:subject, headers:headers, data:data}` |
+| include_row_kind_header | boolean | 否 | true |
+| common-options | - | 否 | - |
+
+### 认证规则
+
+- 配置 `username` 时必须同时配置 `password`,或者只配置 `token`。
+- `token` 不能与 `username` / `password` 同时配置。
+- `password` 和 `token` 都属于敏感配置,不应出现在共享配置文件或日志中。
+
+### subject [string]
+
+- 在 `json` 格式下必须配置。
+- 在 `native` 格式下,只有当 `native_format_fields.subject` 映射到了非空白字段时才可以省略。
+- 在 `native` 格式下,当映射的 subject 字段为 `null`、空字符串或空白字符串时,会回退到该 `subject` 配置。
+
+### native_format_fields [map<string,string>]
+
+仅在 `format = "native"` 时使用。
+
+支持的映射键:
+
+- `data`:必填映射,必须指向 `bytes` 字段
+- `subject`:可选映射,当字段存在于 schema 中时必须指向 `string` 字段
+- `id`:可选映射,当字段存在于 schema 中时必须指向 `string` 字段
+- `headers`:可选映射,当字段存在于 schema 中时必须指向 `map<string,string>` 字段
+
+不支持的映射键会直接校验失败。
+
+当可选映射(`subject`、`id`、`headers`)指向的字段不存在于输入 schema 时,连接器会静默跳过该映射。例如,使用默认映射 `{id:id, subject:subject, headers:headers, data:data}` 时,如果 schema 只包含 `data` 字段,仍然会被接受;`id`、`subject` 和 `headers` 只是不会设置到发布的消息上。
+
+### include_row_kind_header [boolean]
+
+仅在 `format = "native"` 时生效。
+
+- 默认值为 `true`。
+- 启用后,连接器会额外写入 JetStream header `x-seatunnel-row-kind`,值为 SeaTunnel RowKind 名称。
+- 禁用后,连接器不会再自动写入这个生成的 header。
+- 通过 `headers` 映射得到的 headers 仍会正常写入。
+
+### common options
+
+Sink 插件通用参数,请参考 [Sink Common Options](../common-options/sink-common-options.md)。
+
+## 数据契约
+
+### JSON 模式
+
+当 `format = "json"` 时:
+
+- 每条输入行都会被序列化为一个 JSON payload;
+- payload 会写入固定的 sink `subject`;
+- 连接器不会为每条记录额外生成 headers 或 message ID,也不会把 RowKind 元数据写进 JSON payload。
+
+### Native 模式
+
+当 `format = "native"` 时,每一行都会映射成一个 JetStream publish 请求:
+
+- `data` -> 消息 payload,必填,类型必须为 `bytes`
+- `subject` -> 每条记录的 subject,可选,类型必须为 `string`
+- `id` -> JetStream message ID,可选,类型必须为 `string`
+- `headers` -> JetStream headers,可选,类型必须为 `map<string,string>`
+- 当 `include_row_kind_header = true` 时,连接器还会额外写入 JetStream header `x-seatunnel-row-kind`,值为 SeaTunnel RowKind 名称
+
+最终 subject 的解析顺序如下:
+
+1. 如果映射后的 native `subject` 字段为非空白值,则优先使用该值;
+2. 否则使用 sink 的 `subject` 配置;
+3. 如果两者都没有,writer 启动前校验失败。
+
+如果 native `id` 为 `null`、空字符串或空白字符串,则该消息不会带 JetStream message ID。
+
+如果 native `headers` 为 `null`,那么只有在 `include_row_kind_header = true` 时,连接器才会发送自动生成的 `x-seatunnel-row-kind` header。
+
+## RowKind 处理方式
+
+该 Sink 接受所有 SeaTunnel RowKind。
+
+它不会把 `INSERT`、`UPDATE_BEFORE`、`UPDATE_AFTER` 或 `DELETE` 按 CDC 语义解释。每一行都会按照配置的 JSON 或 native 格式作为普通消息发布出去。
+
+在 native 格式下,当 `include_row_kind_header = true` 时,连接器会通过 JetStream header `x-seatunnel-row-kind` 暴露该行的 RowKind。JSON 格式不会在 payload 中包含 RowKind 元数据。
+
+## 示例
+
+### 最小 JSON 示例
+
+```hocon
+env {
+  parallelism = 1
+  job.mode = "BATCH"
+}
+
+source {
+  FakeSource {
+    rows = [
+      {
+        kind = INSERT
+        fields = {
+          id = 101
+          name = "alice"
+          score = 9.5
+        }
+      }
+    ]
+    schema = {
+      fields {
+        id = int
+        name = string
+        score = double
+      }
+    }
+    plugin_output = "json_fake"
+  }
+}
+
+sink {
+  NatsJetStream {
+    plugin_input = "json_fake"
+    url = "nats://127.0.0.1:4222"
+    subject = "orders.json"
+    format = "json"
+  }
+}
+```
+
+产出的 payload:
+
+```json
+{"id":101,"name":"alice","score":9.5}
+```
+
+所有行都会被发布到固定 subject `orders.json`。
+
+### Native 模式示例
+
+```hocon
+env {
+  parallelism = 1
+  job.mode = "BATCH"
+}
+
+source {
+  FakeSource {
+    rows = [
+      {
+        kind = INSERT
+        fields = {
+          dynamic_subject = "events.native.alpha"
+          message_id = "msg-1"
+          attributes = {
+            tenant = "acme"
+            trace = "trace-1"
+          }
+          payload = [1, 35, -1]
+        }
+      },
+      {
+        kind = INSERT
+        fields = {
+          dynamic_subject = "events.native.beta"
+          message_id = "msg-2"
+          attributes = {
+            tenant = "beta"
+            trace = "trace-2"
+          }
+          payload = [112, 97, 121, 108, 111, 97, 100, 45, 50]
+        }
+      }
+    ]
+    schema = {
+      fields {
+        dynamic_subject = string
+        message_id = string
+        attributes = "map<string,string>"
+        payload = bytes
+      }
+    }
+    plugin_output = "native_fake"
+  }
+}
+
+sink {
+  NatsJetStream {
+    plugin_input = "native_fake"
+    url = "nats://127.0.0.1:4222"
+    subject = "events.native.default"
+    format = "native"
+    native_format_fields = {
+      subject = dynamic_subject
+      id = message_id
+      headers = attributes
+      data = payload
+    }
+  }
+}
+```
+
+第一条记录映射后的结果:
+
+- subject: `events.native.alpha`
+- message ID: `msg-1`
+- headers: `tenant=acme`、`trace=trace-1`
+- payload bytes: `[1, 35, -1]`
+
+如果 `dynamic_subject` 是空白值或 `null`,连接器会回退到 `subject = "events.native.default"`。
+
+### 使用显式默认字段映射的 Native 模式
+
+如果输入 schema 已经直接包含 `subject`、`id`、`headers` 和 `data` 字段,可以使用下面这组默认映射值。
+
+```hocon
+native_format_fields = {
+  subject = subject
+  id = id
+  headers = headers
+  data = data
+}
+```
+
+在 native 模式下,`native_format_fields` 仍然需要提供 `data` 映射。
+
+输入 schema 契约:
+
+```text
+subject : string
+id      : string
+headers : map<string,string>
+data    : bytes
+```
+
+## 错误与运维说明
+
+- 连接失败会导致 writer 启动失败。
+- publish 失败会让任务失败,错误信息中会包含目标 subject。
+- stream 绑定缺失、subject 配置错误或 JetStream API 返回异常,通常会在第一条消息 publish 时暴露。
+- writer 采用逐条同步 publish,因此吞吐受 JetStream acknowledgement 延迟影响明显。
+
+## 不支持的能力与限制
+
+- 不提供 exactly-once。
+- 不支持脱离 JetStream 的 core NATS publish 模式。
+- 不支持自动创建、更新或删除 stream。
+- 不支持由连接器配置 JetStream deduplication window。
+- 不支持把非 `bytes` 列自动转换成 native payload。
+- 不支持基于 RowKind 的 CDC 更新/删除语义。
+
+## FAQ
+
+### 这是一个 core NATS publisher 吗?
+
+不是。它通过 JetStream API 发布消息,并依赖服务端已经准备好的 JetStream 资源。
+
+### 连接器会自动创建 stream 吗?
+
+不会。作业启动前必须先创建 stream,并把它绑定到发布 subject。
+
+### message ID 能让投递变成 exactly-once 吗?
+
+不能。message ID 只能在目标 stream 已配置 duplicate window,且生产端重复发送相同稳定 ID 时,帮助 JetStream 做重复抑制。
+
+## 变更日志
+
+<ChangeLog />
diff --git a/plugin-mapping.properties b/plugin-mapping.properties
index d4b0b1e138..4b106d0032 100644
--- a/plugin-mapping.properties
+++ b/plugin-mapping.properties
@@ -165,6 +165,7 @@ seatunnel.source.Fluss = connector-fluss
 seatunnel.sink.Fluss = connector-fluss
 seatunnel.sink.Lance = connector-lance
 seatunnel.sink.BigQuery = connector-bigquery
+seatunnel.sink.NatsJetStream = connector-nats-jetstream
 
 # For custom transforms, make sure to use the seatunnel.transform.[PluginIdentifier]=[JarPerfix] naming convention. For example:
 # seatunnel.transform.Sql = seatunnel-transforms-v2
diff --git a/seatunnel-connectors-v2/connector-nats-jetstream/pom.xml b/seatunnel-connectors-v2/connector-nats-jetstream/pom.xml
new file mode 100644
index 0000000000..7eb305c52d
--- /dev/null
+++ b/seatunnel-connectors-v2/connector-nats-jetstream/pom.xml
@@ -0,0 +1,56 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+
+    Licensed to the Apache Software Foundation (ASF) under one or more
+    contributor license agreements.  See the NOTICE file distributed with
+    this work for additional information regarding copyright ownership.
+    The ASF licenses this file to You under the Apache License, Version 2.0
+    (the "License"); you may not use this file except in compliance with
+    the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>org.apache.seatunnel</groupId>
+        <artifactId>seatunnel-connectors-v2</artifactId>
+        <version>${revision}</version>
+    </parent>
+
+    <artifactId>connector-nats-jetstream</artifactId>
+    <name>SeaTunnel : Connectors V2 : NATS Jetstream</name>
+
+    <properties>
+        <nats.client.version>2.24.0</nats.client.version>
+    </properties>
+
+    <dependencies>
+
+        <!-- TODO add to dependency management after version unify-->
+        <dependency>
+            <groupId>org.apache.seatunnel</groupId>
+            <artifactId>connector-common</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.seatunnel</groupId>
+            <artifactId>seatunnel-format-json</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>io.nats</groupId>
+            <artifactId>jnats</artifactId>
+            <version>${nats.client.version}</version>
+        </dependency>
+    </dependencies>
+
+</project>
diff --git a/seatunnel-connectors-v2/connector-nats-jetstream/src/main/java/org/apache/seatunnel/connectors/seatunnel/natsjetstream/config/NatsJetStreamMessageFormat.java b/seatunnel-connectors-v2/connector-nats-jetstream/src/main/java/org/apache/seatunnel/connectors/seatunnel/natsjetstream/config/NatsJetStreamMessageFormat.java
new file mode 100644
index 0000000000..ba3a128f39
--- /dev/null
+++ b/seatunnel-connectors-v2/connector-nats-jetstream/src/main/java/org/apache/seatunnel/connectors/seatunnel/natsjetstream/config/NatsJetStreamMessageFormat.java
@@ -0,0 +1,23 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.seatunnel.connectors.seatunnel.natsjetstream.config;
+
+public enum NatsJetStreamMessageFormat {
+    JSON,
+    NATIVE
+}
diff --git a/seatunnel-connectors-v2/connector-nats-jetstream/src/main/java/org/apache/seatunnel/connectors/seatunnel/natsjetstream/config/NatsJetStreamSinkOptions.java b/seatunnel-connectors-v2/connector-nats-jetstream/src/main/java/org/apache/seatunnel/connectors/seatunnel/natsjetstream/config/NatsJetStreamSinkOptions.java
new file mode 100644
index 0000000000..08e1b2b310
--- /dev/null
+++ b/seatunnel-connectors-v2/connector-nats-jetstream/src/main/java/org/apache/seatunnel/connectors/seatunnel/natsjetstream/config/NatsJetStreamSinkOptions.java
@@ -0,0 +1,111 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.seatunnel.connectors.seatunnel.natsjetstream.config;
+
+import org.apache.seatunnel.api.configuration.Option;
+import org.apache.seatunnel.api.configuration.Options;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+public class NatsJetStreamSinkOptions {
+    public static final String CONNECTOR_IDENTITY = "NatsJetStream";
+
+    public static final String NATIVE_MAPPING_ID = "id";
+    public static final String NATIVE_MAPPING_SUBJECT = "subject";
+    public static final String NATIVE_MAPPING_HEADERS = "headers";
+    public static final String NATIVE_MAPPING_DATA = "data";
+
+    public static final Option<String> URL =
+            Options.key("url")
+                    .stringType()
+                    .noDefaultValue()
+                    .withDescription(
+                            "NATS server address used by the sink, for example `nats://127.0.0.1:4222`."
+                                    + " Keep credentials out of the URL and configure `username`/`password` or `token` separately.");
+
+    public static final Option<String> USERNAME =
+            Options.key("username")
+                    .stringType()
+                    .noDefaultValue()
+                    .withDescription(
+                            "Username for NATS authentication. This option must be configured together with `password`"
+                                    + " and must not be combined with `token`.");
+
+    public static final Option<String> PASSWORD =
+            Options.key("password")
+                    .stringType()
+                    .noDefaultValue()
+                    .withDescription(
+                            "Password for NATS authentication. This option must be configured together with `username`"
+                                    + " and must not be combined with `token`.");
+
+    public static final Option<String> TOKEN =
+            Options.key("token")
+                    .stringType()
+                    .noDefaultValue()
+                    .withDescription(
+                            "Authentication token for NATS. Configure either `token` or the `username`/`password` pair.");
+
+    public static final Option<String> SUBJECT =
+            Options.key("subject")
+                    .stringType()
+                    .noDefaultValue()
+                    .withDescription(
+                            "Default JetStream subject used for published messages. This option is required in `json` format"
+                                    + " and is used as the fallback subject in `native` format when the mapped subject field is null.");
+
+    public static final Option<NatsJetStreamMessageFormat> FORMAT =
+            Options.key("format")
+                    .enumType(NatsJetStreamMessageFormat.class)
+                    .defaultValue(NatsJetStreamMessageFormat.JSON)
+                    .withDescription(
+                            "Message format written to JetStream. Supported values are `json` and `native`.");
+
+    public static final Option<Map<String, String>> NATIVE_FIELDS =
+            Options.key("native_format_fields")
+                    .mapType()
+                    .defaultValue(getDefaultNativeFields())
+                    .withDescription(
+                            "Field mapping used only when `format = native`. Supported mapping keys are `id`, `subject`, `headers`, and `data`."
+                                    + " Values are SeaTunnel field names. The default mapping is "
+                                    + "`{\"id\":\"id\",\"subject\":\"subject\",\"headers\":\"headers\",\"data\":\"data\"}`."
+                                    + " Optional mappings (`id`, `subject`, `headers`) are silently skipped when the mapped field"
+                                    + " does not exist in the input schema. `data` must map to a BYTES field,"
+                                    + " `subject` and `id` must map to STRING fields when present,"
+                                    + " and `headers` must map to MAP<STRING, STRING> when present.");
+
+    public static final Option<Boolean> INCLUDE_ROW_KIND_HEADER =
+            Options.key("include_row_kind_header")
+                    .booleanType()
+                    .defaultValue(true)
+                    .withDescription(
+                            "Whether to add JetStream header `x-seatunnel-row-kind` in `native` format."
+                                    + " When enabled, the header value is the SeaTunnel row kind name."
+                                    + " This option has no effect in `json` format.");
+
+    public static Map<String, String> getDefaultNativeFields() {
+        Map<String, String> map = new HashMap<>();
+        map.put(NATIVE_MAPPING_ID, NATIVE_MAPPING_ID);
+        map.put(NATIVE_MAPPING_SUBJECT, NATIVE_MAPPING_SUBJECT);
+        map.put(NATIVE_MAPPING_HEADERS, NATIVE_MAPPING_HEADERS);
+        map.put(NATIVE_MAPPING_DATA, NATIVE_MAPPING_DATA);
+        return Collections.unmodifiableMap(map);
+    }
+}
diff --git a/seatunnel-connectors-v2/connector-nats-jetstream/src/main/java/org/apache/seatunnel/connectors/seatunnel/natsjetstream/exception/NatsJetStreamConnectorException.java b/seatunnel-connectors-v2/connector-nats-jetstream/src/main/java/org/apache/seatunnel/connectors/seatunnel/natsjetstream/exception/NatsJetStreamConnectorException.java
new file mode 100644
index 0000000000..715b6ee099
--- /dev/null
+++ b/seatunnel-connectors-v2/connector-nats-jetstream/src/main/java/org/apache/seatunnel/connectors/seatunnel/natsjetstream/exception/NatsJetStreamConnectorException.java
@@ -0,0 +1,34 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.seatunnel.connectors.seatunnel.natsjetstream.exception;
+
+import org.apache.seatunnel.common.exception.SeaTunnelErrorCode;
+import org.apache.seatunnel.common.exception.SeaTunnelRuntimeException;
+
+public class NatsJetStreamConnectorException extends SeaTunnelRuntimeException {
+
+    public NatsJetStreamConnectorException(
+            SeaTunnelErrorCode seaTunnelErrorCode, String errorMessage) {
+        super(seaTunnelErrorCode, errorMessage);
+    }
+
+    public NatsJetStreamConnectorException(
+            SeaTunnelErrorCode seaTunnelErrorCode, String errorMessage, Throwable cause) {
+        super(seaTunnelErrorCode, errorMessage, cause);
+    }
+}
diff --git a/seatunnel-connectors-v2/connector-nats-jetstream/src/main/java/org/apache/seatunnel/connectors/seatunnel/natsjetstream/sink/NatsJetStreamRequestSerializer.java b/seatunnel-connectors-v2/connector-nats-jetstream/src/main/java/org/apache/seatunnel/connectors/seatunnel/natsjetstream/sink/NatsJetStreamRequestSerializer.java
new file mode 100644
index 0000000000..8e51168286
--- /dev/null
+++ b/seatunnel-connectors-v2/connector-nats-jetstream/src/main/java/org/apache/seatunnel/connectors/seatunnel/natsjetstream/sink/NatsJetStreamRequestSerializer.java
@@ -0,0 +1,165 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.seatunnel.connectors.seatunnel.natsjetstream.sink;
+
+import org.apache.seatunnel.api.serialization.SerializationSchema;
+import org.apache.seatunnel.api.table.type.SeaTunnelRow;
+import org.apache.seatunnel.connectors.seatunnel.natsjetstream.sink.NatsJetStreamSinkWriter.NativeFieldMapping;
+import org.apache.seatunnel.connectors.seatunnel.natsjetstream.sink.NatsJetStreamSinkWriter.PublishRequest;
+
+import io.nats.client.impl.Headers;
+
+import java.util.Map;
+
+final class NatsJetStreamRequestSerializer {
+
+    static final String ROW_KIND_HEADER = "x-seatunnel-row-kind";
+
+    private final String defaultSubject;
+    private final SerializationSchema serializationSchema;
+    private final boolean includeRowKindHeader;
+    private final NativeFieldMapping nativeFieldMapping;
+
+    private NatsJetStreamRequestSerializer(
+            String defaultSubject,
+            SerializationSchema serializationSchema,
+            boolean includeRowKindHeader,
+            NativeFieldMapping nativeFieldMapping) {
+        this.defaultSubject = defaultSubject;
+        this.serializationSchema = serializationSchema;
+        this.includeRowKindHeader = includeRowKindHeader;
+        this.nativeFieldMapping = nativeFieldMapping;
+    }
+
+    static NatsJetStreamRequestSerializer forJson(
+            String defaultSubject, SerializationSchema serializationSchema) {
+        return new NatsJetStreamRequestSerializer(defaultSubject, serializationSchema, false, null);
+    }
+
+    static NatsJetStreamRequestSerializer forNative(
+            String defaultSubject,
+            boolean includeRowKindHeader,
+            NativeFieldMapping nativeFieldMapping) {
+        return new NatsJetStreamRequestSerializer(
+                defaultSubject, null, includeRowKindHeader, nativeFieldMapping);
+    }
+
+    PublishRequest serialize(SeaTunnelRow element) {
+        if (nativeFieldMapping == null) {
+            return new PublishRequest(
+                    defaultSubject, null, null, serializationSchema.serialize(element));
+        }
+        String subject = defaultSubject;
+        if (nativeFieldMapping.subjectFieldIndex >= 0) {
+            subject = resolveSubjectField(element, nativeFieldMapping.subjectFieldIndex, subject);
+        }
+        if (subject == null || subject.isEmpty()) {
+            throw NatsJetStreamSinkWriter.invalidRecord("subject", "must not be null or blank");
+        }
+
+        String messageId = null;
+        if (nativeFieldMapping.messageIdFieldIndex >= 0) {
+            messageId =
+                    resolveOptionalStringField(
+                            element, nativeFieldMapping.messageIdFieldIndex, "id");
+        }
+
+        Headers headers = null;
+        if (includeRowKindHeader) {
+            headers = withRowKindHeader(element);
+        }
+        if (nativeFieldMapping.headersFieldIndex >= 0) {
+            headers = requireHeaders(element, nativeFieldMapping.headersFieldIndex, headers);
+        }
+
+        byte[] data = requireBinaryPayload(element, nativeFieldMapping.dataFieldIndex);
+        return new PublishRequest(subject, messageId, headers, data);
+    }
+
+    private static Headers requireHeaders(SeaTunnelRow element, int fieldIndex, Headers headers) {
+        Object headersValue = element.getField(fieldIndex);
+        if (headersValue == null) {
+            return headers;
+        }
+        if (headers == null) {
+            headers = new Headers();
+        }
+        if (!(headersValue instanceof Map)) {
+            throw NatsJetStreamSinkWriter.invalidRecord(
+                    "headers", "must be a map of string keys and values");
+        }
+        Map<?, ?> rawHeaders = (Map<?, ?>) headersValue;
+        for (Map.Entry<?, ?> entry : rawHeaders.entrySet()) {
+            if (!(entry.getKey() instanceof String)) {
+                throw NatsJetStreamSinkWriter.invalidRecord("headers", "contains a non-string key");
+            }
+            if (!(entry.getValue() instanceof String)) {
+                throw NatsJetStreamSinkWriter.invalidRecord(
+                        "headers", "contains a non-string value");
+            }
+            headers.add((String) entry.getKey(), (String) entry.getValue());
+        }
+        return headers;
+    }
+
+    private static byte[] requireBinaryPayload(SeaTunnelRow element, int fieldIndex) {
+        Object value = element.getField(fieldIndex);
+        if (!(value instanceof byte[])) {
+            throw NatsJetStreamSinkWriter.invalidRecord("data", "must be a non-null BYTES value");
+        }
+        return (byte[]) value;
+    }
+
+    private static Headers withRowKindHeader(SeaTunnelRow element) {
+        Headers headers = new Headers();
+        headers.add(ROW_KIND_HEADER, element.getRowKind().name());
+        return headers;
+    }
+
+    private static String resolveSubjectField(
+            SeaTunnelRow element, int fieldIndex, String fallbackSubject) {
+        Object value = element.getField(fieldIndex);
+        if (value == null) {
+            return fallbackSubject;
+        }
+        if (!(value instanceof String)) {
+            throw NatsJetStreamSinkWriter.invalidRecord("subject", "must be a STRING value");
+        }
+        String subject = ((String) value).trim();
+        if (subject.isEmpty()) {
+            return fallbackSubject;
+        }
+        return subject;
+    }
+
+    private static String resolveOptionalStringField(
+            SeaTunnelRow element, int fieldIndex, String fieldName) {
+        Object value = element.getField(fieldIndex);
+        if (value == null) {
+            return null;
+        }
+        if (!(value instanceof String)) {
+            throw NatsJetStreamSinkWriter.invalidRecord(fieldName, "must be a STRING value");
+        }
+        String stringValue = ((String) value).trim();
+        if (stringValue.isEmpty()) {
+            return null;
+        }
+        return stringValue;
+    }
+}
diff --git a/seatunnel-connectors-v2/connector-nats-jetstream/src/main/java/org/apache/seatunnel/connectors/seatunnel/natsjetstream/sink/NatsJetStreamSink.java b/seatunnel-connectors-v2/connector-nats-jetstream/src/main/java/org/apache/seatunnel/connectors/seatunnel/natsjetstream/sink/NatsJetStreamSink.java
new file mode 100644
index 0000000000..998f457ce1
--- /dev/null
+++ b/seatunnel-connectors-v2/connector-nats-jetstream/src/main/java/org/apache/seatunnel/connectors/seatunnel/natsjetstream/sink/NatsJetStreamSink.java
@@ -0,0 +1,59 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.seatunnel.connectors.seatunnel.natsjetstream.sink;
+
+import org.apache.seatunnel.api.configuration.ReadonlyConfig;
+import org.apache.seatunnel.api.sink.SeaTunnelSink;
+import org.apache.seatunnel.api.sink.SinkWriter;
+import org.apache.seatunnel.api.sink.SinkWriter.Context;
+import org.apache.seatunnel.api.table.catalog.CatalogTable;
+import org.apache.seatunnel.api.table.type.SeaTunnelRow;
+import org.apache.seatunnel.api.table.type.SeaTunnelRowType;
+import org.apache.seatunnel.connectors.seatunnel.natsjetstream.config.NatsJetStreamSinkOptions;
+
+import java.io.IOException;
+import java.util.Optional;
+
+public class NatsJetStreamSink implements SeaTunnelSink<SeaTunnelRow, Void, Void, Void> {
+
+    private final ReadonlyConfig pluginConfig;
+    private final SeaTunnelRowType seaTunnelRowType;
+    private final CatalogTable catalogTable;
+
+    public NatsJetStreamSink(ReadonlyConfig pluginConfig, CatalogTable catalogTable) {
+        NatsJetStreamSinkValidator.validate(pluginConfig, catalogTable);
+        this.pluginConfig = pluginConfig;
+        this.catalogTable = catalogTable;
+        this.seaTunnelRowType = catalogTable.getTableSchema().toPhysicalRowDataType();
+    }
+
+    @Override
+    public String getPluginName() {
+        return NatsJetStreamSinkOptions.CONNECTOR_IDENTITY;
+    }
+
+    @Override
+    public SinkWriter<SeaTunnelRow, Void, Void> createWriter(Context arg0) throws IOException {
+        return new NatsJetStreamSinkWriter(arg0, seaTunnelRowType, pluginConfig, catalogTable);
+    }
+
+    @Override
+    public Optional<CatalogTable> getWriteCatalogTable() {
+        return Optional.ofNullable(catalogTable);
+    }
+}
diff --git a/seatunnel-connectors-v2/connector-nats-jetstream/src/main/java/org/apache/seatunnel/connectors/seatunnel/natsjetstream/sink/NatsJetStreamSinkFactory.java b/seatunnel-connectors-v2/connector-nats-jetstream/src/main/java/org/apache/seatunnel/connectors/seatunnel/natsjetstream/sink/NatsJetStreamSinkFactory.java
new file mode 100644
index 0000000000..b95491ce0f
--- /dev/null
+++ b/seatunnel-connectors-v2/connector-nats-jetstream/src/main/java/org/apache/seatunnel/connectors/seatunnel/natsjetstream/sink/NatsJetStreamSinkFactory.java
@@ -0,0 +1,61 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.seatunnel.connectors.seatunnel.natsjetstream.sink;
+
+import org.apache.seatunnel.api.configuration.ReadonlyConfig;
+import org.apache.seatunnel.api.configuration.util.OptionRule;
+import org.apache.seatunnel.api.table.catalog.CatalogTable;
+import org.apache.seatunnel.api.table.connector.TableSink;
+import org.apache.seatunnel.api.table.factory.Factory;
+import org.apache.seatunnel.api.table.factory.TableSinkFactory;
+import org.apache.seatunnel.api.table.factory.TableSinkFactoryContext;
+import org.apache.seatunnel.connectors.seatunnel.natsjetstream.config.NatsJetStreamSinkOptions;
+
+import com.google.auto.service.AutoService;
+
+@AutoService(Factory.class)
+public class NatsJetStreamSinkFactory implements TableSinkFactory {
+
+    @Override
+    public String factoryIdentifier() {
+        return NatsJetStreamSinkOptions.CONNECTOR_IDENTITY;
+    }
+
+    @Override
+    public OptionRule optionRule() {
+        return OptionRule.builder()
+                .required(NatsJetStreamSinkOptions.URL)
+                .optional(
+                        NatsJetStreamSinkOptions.USERNAME,
+                        NatsJetStreamSinkOptions.PASSWORD,
+                        NatsJetStreamSinkOptions.TOKEN,
+                        NatsJetStreamSinkOptions.SUBJECT,
+                        NatsJetStreamSinkOptions.FORMAT,
+                        NatsJetStreamSinkOptions.NATIVE_FIELDS,
+                        NatsJetStreamSinkOptions.INCLUDE_ROW_KIND_HEADER)
+                .build();
+    }
+
+    @Override
+    public TableSink createSink(TableSinkFactoryContext context) {
+        ReadonlyConfig options = context.getOptions();
+        CatalogTable catalogTable = context.getCatalogTable();
+        NatsJetStreamSinkValidator.validate(options, catalogTable);
+        return () -> new NatsJetStreamSink(options, catalogTable);
+    }
+}
diff --git a/seatunnel-connectors-v2/connector-nats-jetstream/src/main/java/org/apache/seatunnel/connectors/seatunnel/natsjetstream/sink/NatsJetStreamSinkValidator.java b/seatunnel-connectors-v2/connector-nats-jetstream/src/main/java/org/apache/seatunnel/connectors/seatunnel/natsjetstream/sink/NatsJetStreamSinkValidator.java
new file mode 100644
index 0000000000..df06f855e3
--- /dev/null
+++ b/seatunnel-connectors-v2/connector-nats-jetstream/src/main/java/org/apache/seatunnel/connectors/seatunnel/natsjetstream/sink/NatsJetStreamSinkValidator.java
@@ -0,0 +1,249 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.seatunnel.connectors.seatunnel.natsjetstream.sink;
+
+import org.apache.seatunnel.api.configuration.ReadonlyConfig;
+import org.apache.seatunnel.api.table.catalog.CatalogTable;
+import org.apache.seatunnel.api.table.type.MapType;
+import org.apache.seatunnel.api.table.type.SeaTunnelDataType;
+import org.apache.seatunnel.api.table.type.SeaTunnelRowType;
+import org.apache.seatunnel.api.table.type.SqlType;
+import org.apache.seatunnel.common.exception.CommonErrorCodeDeprecated;
+import org.apache.seatunnel.connectors.seatunnel.natsjetstream.config.NatsJetStreamMessageFormat;
+import org.apache.seatunnel.connectors.seatunnel.natsjetstream.config.NatsJetStreamSinkOptions;
+import org.apache.seatunnel.connectors.seatunnel.natsjetstream.exception.NatsJetStreamConnectorException;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+
+final class NatsJetStreamSinkValidator {
+
+    private static final Set<String> SUPPORTED_NATIVE_MAPPING_KEYS =
+            new HashSet<>(
+                    Arrays.asList(
+                            NatsJetStreamSinkOptions.NATIVE_MAPPING_ID,
+                            NatsJetStreamSinkOptions.NATIVE_MAPPING_SUBJECT,
+                            NatsJetStreamSinkOptions.NATIVE_MAPPING_HEADERS,
+                            NatsJetStreamSinkOptions.NATIVE_MAPPING_DATA));
+
+    private NatsJetStreamSinkValidator() {}
+
+    static void validate(ReadonlyConfig pluginConfig, CatalogTable catalogTable) {
+        requireNonBlank(pluginConfig, NatsJetStreamSinkOptions.URL);
+        validateAuthentication(pluginConfig);
+        NatsJetStreamMessageFormat format = pluginConfig.get(NatsJetStreamSinkOptions.FORMAT);
+        if (format == null) {
+            throw invalidOption("format", "must be one of: json, native");
+        }
+        if (format == NatsJetStreamMessageFormat.JSON) {
+            requireNonBlank(pluginConfig, NatsJetStreamSinkOptions.SUBJECT);
+            return;
+        }
+        validateNativeMapping(pluginConfig, catalogTable);
+    }
+
+    private static void validateAuthentication(ReadonlyConfig pluginConfig) {
+        Optional<String> username = pluginConfig.getOptional(NatsJetStreamSinkOptions.USERNAME);
+        Optional<String> password = pluginConfig.getOptional(NatsJetStreamSinkOptions.PASSWORD);
+        Optional<String> token = pluginConfig.getOptional(NatsJetStreamSinkOptions.TOKEN);
+
+        boolean hasUsername = username.map(NatsJetStreamSinkValidator::isNotBlank).orElse(false);
+        boolean hasPassword = password.map(NatsJetStreamSinkValidator::isNotBlank).orElse(false);
+        boolean hasToken = token.map(NatsJetStreamSinkValidator::isNotBlank).orElse(false);
+
+        if (hasUsername != hasPassword) {
+            throw invalidOption(
+                    hasUsername
+                            ? NatsJetStreamSinkOptions.PASSWORD.key()
+                            : NatsJetStreamSinkOptions.USERNAME.key(),
+                    "must be configured together with `"
+                            + (hasUsername
+                                    ? NatsJetStreamSinkOptions.USERNAME.key()
+                                    : NatsJetStreamSinkOptions.PASSWORD.key())
+                            + "`");
+        }
+        if (hasToken && hasUsername) {
+            throw invalidOption(
+                    NatsJetStreamSinkOptions.TOKEN.key(),
+                    "cannot be configured together with `username` and `password`");
+        }
+    }
+
+    private static void validateNativeMapping(
+            ReadonlyConfig pluginConfig, CatalogTable catalogTable) {
+        Map<String, String> nativeFields = pluginConfig.get(NatsJetStreamSinkOptions.NATIVE_FIELDS);
+        if (nativeFields == null || nativeFields.isEmpty()) {
+            throw invalidOption(
+                    NatsJetStreamSinkOptions.NATIVE_FIELDS.key(),
+                    "must define at least the `data` field mapping in native format");
+        }
+
+        for (String mappingKey : nativeFields.keySet()) {
+            if (!SUPPORTED_NATIVE_MAPPING_KEYS.contains(mappingKey)) {
+                throw invalidOption(
+                        NatsJetStreamSinkOptions.NATIVE_FIELDS.key(),
+                        "contains unsupported mapping key `" + mappingKey + "`");
+            }
+        }
+
+        String dataField = nativeFields.get(NatsJetStreamSinkOptions.NATIVE_MAPPING_DATA);
+        if (!isNotBlank(dataField)) {
+            throw invalidOption(
+                    NatsJetStreamSinkOptions.NATIVE_FIELDS.key(),
+                    "must define a non-empty mapping for `data`");
+        }
+
+        SeaTunnelRowType rowType = catalogTable.getSeaTunnelRowType();
+        validateMappedFieldType(
+                rowType, NatsJetStreamSinkOptions.NATIVE_MAPPING_DATA, dataField, SqlType.BYTES);
+
+        validateOptionalStringField(
+                rowType, nativeFields, NatsJetStreamSinkOptions.NATIVE_MAPPING_ID);
+        validateOptionalHeadersField(rowType, nativeFields);
+
+        String subject = pluginConfig.getOptional(NatsJetStreamSinkOptions.SUBJECT).orElse(null);
+        boolean hasSubjectFallback = isNotBlank(subject);
+        boolean hasSubjectField =
+                isNotBlank(nativeFields.get(NatsJetStreamSinkOptions.NATIVE_MAPPING_SUBJECT));
+        if (!hasSubjectFallback && !hasSubjectField) {
+            throw invalidOption(
+                    NatsJetStreamSinkOptions.SUBJECT.key(),
+                    "or `native_format_fields.subject` must be configured in native format");
+        }
+        validateSubjectField(rowType, nativeFields, hasSubjectFallback);
+    }
+
+    /**
+     * Validates the native {@code subject} field mapping. Unlike other optional mappings, the
+     * subject mapping is required to resolve to an existing {@code STRING} field whenever no
+     * sink-level {@code subject} fallback is configured. Without this check, a subject mapping that
+     * points to a non-existent field silently resolves to {@code null} at runtime and every row is
+     * rejected by the serializer.
+     */
+    private static void validateSubjectField(
+            SeaTunnelRowType rowType,
+            Map<String, String> nativeFields,
+            boolean hasSubjectFallback) {
+        String fieldName = nativeFields.get(NatsJetStreamSinkOptions.NATIVE_MAPPING_SUBJECT);
+        if (!isNotBlank(fieldName)) {
+            return;
+        }
+        int fieldIndex = rowType.indexOf(fieldName, false);
+        if (fieldIndex < 0) {
+            if (!hasSubjectFallback) {
+                throw invalidField(
+                        fieldName,
+                        "mapped from `"
+                                + NatsJetStreamSinkOptions.NATIVE_FIELDS.key()
+                                + ".subject` does not exist in table schema");
+            }
+            return;
+        }
+        SeaTunnelDataType<?> fieldType = rowType.getFieldType(fieldIndex);
+        if (fieldType.getSqlType() != SqlType.STRING) {
+            throw invalidField(fieldName, "must use `STRING` type for native mapping `subject`");
+        }
+    }
+
+    private static void validateOptionalStringField(
+            SeaTunnelRowType rowType, Map<String, String> nativeFields, String mappingKey) {
+        String fieldName = nativeFields.get(mappingKey);
+        if (!isNotBlank(fieldName)) {
+            return;
+        }
+        int fieldIndex = rowType.indexOf(fieldName, false);
+        if (fieldIndex < 0) {
+            return;
+        }
+        SeaTunnelDataType<?> fieldType = rowType.getFieldType(fieldIndex);
+        if (fieldType.getSqlType() != SqlType.STRING) {
+            throw invalidField(
+                    fieldName, "must use `STRING` type for native mapping `" + mappingKey + "`");
+        }
+    }
+
+    private static void validateOptionalHeadersField(
+            SeaTunnelRowType rowType, Map<String, String> nativeFields) {
+        String fieldName = nativeFields.get(NatsJetStreamSinkOptions.NATIVE_MAPPING_HEADERS);
+        if (!isNotBlank(fieldName)) {
+            return;
+        }
+        int fieldIndex = rowType.indexOf(fieldName, false);
+        if (fieldIndex < 0) {
+            return;
+        }
+        SeaTunnelDataType<?> fieldType = rowType.getFieldType(fieldIndex);
+        if (!(fieldType instanceof MapType)) {
+            throw invalidField(fieldName, "must use MAP<STRING, STRING> type");
+        }
+        MapType<?, ?> mapType = (MapType<?, ?>) fieldType;
+        if (mapType.getKeyType().getSqlType() != SqlType.STRING
+                || mapType.getValueType().getSqlType() != SqlType.STRING) {
+            throw invalidField(fieldName, "must use MAP<STRING, STRING> type");
+        }
+    }
+
+    private static void validateMappedFieldType(
+            SeaTunnelRowType rowType, String mappingKey, String fieldName, SqlType expectedType) {
+        int fieldIndex = rowType.indexOf(fieldName, false);
+        if (fieldIndex < 0) {
+            throw invalidField(
+                    fieldName,
+                    "mapped from `"
+                            + NatsJetStreamSinkOptions.NATIVE_FIELDS.key()
+                            + "."
+                            + mappingKey
+                            + "` does not exist in table schema");
+        }
+        SeaTunnelDataType<?> fieldType = rowType.getFieldType(fieldIndex);
+        if (fieldType.getSqlType() != expectedType) {
+            throw invalidField(
+                    fieldName,
+                    "must use `" + expectedType + "` type for native mapping `" + mappingKey + "`");
+        }
+    }
+
+    private static void requireNonBlank(
+            ReadonlyConfig pluginConfig,
+            org.apache.seatunnel.api.configuration.Option<String> option) {
+        String value = pluginConfig.getOptional(option).orElse(null);
+        if (!isNotBlank(value)) {
+            throw invalidOption(option.key(), "must not be blank");
+        }
+    }
+
+    private static boolean isNotBlank(String value) {
+        return value != null && !value.trim().isEmpty();
+    }
+
+    private static NatsJetStreamConnectorException invalidOption(
+            String optionName, String message) {
+        return new NatsJetStreamConnectorException(
+                CommonErrorCodeDeprecated.ILLEGAL_ARGUMENT,
+                "Invalid NATS JetStream sink option `" + optionName + "`: " + message);
+    }
+
+    private static NatsJetStreamConnectorException invalidField(String fieldName, String message) {
+        return new NatsJetStreamConnectorException(
+                CommonErrorCodeDeprecated.ILLEGAL_ARGUMENT,
+                "Invalid NATS JetStream sink field `" + fieldName + "`: " + message);
+    }
+}
diff --git a/seatunnel-connectors-v2/connector-nats-jetstream/src/main/java/org/apache/seatunnel/connectors/seatunnel/natsjetstream/sink/NatsJetStreamSinkWriter.java b/seatunnel-connectors-v2/connector-nats-jetstream/src/main/java/org/apache/seatunnel/connectors/seatunnel/natsjetstream/sink/NatsJetStreamSinkWriter.java
new file mode 100644
index 0000000000..b06bcbab99
--- /dev/null
+++ b/seatunnel-connectors-v2/connector-nats-jetstream/src/main/java/org/apache/seatunnel/connectors/seatunnel/natsjetstream/sink/NatsJetStreamSinkWriter.java
@@ -0,0 +1,294 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.seatunnel.connectors.seatunnel.natsjetstream.sink;
+
+import org.apache.seatunnel.api.configuration.ReadonlyConfig;
+import org.apache.seatunnel.api.sink.SinkWriter;
+import org.apache.seatunnel.api.table.catalog.CatalogTable;
+import org.apache.seatunnel.api.table.type.SeaTunnelRow;
+import org.apache.seatunnel.api.table.type.SeaTunnelRowType;
+import org.apache.seatunnel.common.exception.CommonErrorCodeDeprecated;
+import org.apache.seatunnel.connectors.seatunnel.natsjetstream.config.NatsJetStreamMessageFormat;
+import org.apache.seatunnel.connectors.seatunnel.natsjetstream.config.NatsJetStreamSinkOptions;
+import org.apache.seatunnel.connectors.seatunnel.natsjetstream.exception.NatsJetStreamConnectorException;
+import org.apache.seatunnel.format.json.JsonSerializationSchema;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import io.nats.client.Connection;
+import io.nats.client.JetStream;
+import io.nats.client.JetStreamApiException;
+import io.nats.client.Nats;
+import io.nats.client.Options;
+import io.nats.client.PublishOptions;
+import io.nats.client.impl.Headers;
+
+import java.io.IOException;
+import java.time.Duration;
+import java.util.Map;
+import java.util.Optional;
+
+public class NatsJetStreamSinkWriter implements SinkWriter<SeaTunnelRow, Void, Void> {
+
+    private static final Logger LOG = LoggerFactory.getLogger(NatsJetStreamSinkWriter.class);
+    private static final Duration CONNECT_TIMEOUT = Duration.ofSeconds(30);
+    private static final Duration PUBLISH_TIMEOUT = Duration.ofSeconds(30);
+
+    private final int subtaskIndex;
+    private final NatsJetStreamRequestSerializer requestSerializer;
+
+    private Connection connection;
+    private JetStream jetStream;
+
+    public NatsJetStreamSinkWriter(
+            Context context,
+            SeaTunnelRowType seaTunnelRowType,
+            ReadonlyConfig pluginConfig,
+            CatalogTable catalogTable)
+            throws IOException {
+
+        NatsJetStreamSinkValidator.validate(pluginConfig, catalogTable);
+        this.subtaskIndex = context.getIndexOfSubtask();
+        this.requestSerializer = createRequestSerializer(seaTunnelRowType, pluginConfig);
+        connect(pluginConfig);
+        LOG.info("Opened NATS JetStream sink writer for subtask {}", subtaskIndex);
+    }
+
+    @Override
+    public void abortPrepare() {}
+
+    @Override
+    public void close() throws IOException {
+        IOException closeException = null;
+        if (connection != null) {
+            try {
+                connection.close();
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+                closeException = new IOException("Interrupted while closing NATS connection", e);
+            } finally {
+                jetStream = null;
+                connection = null;
+            }
+        }
+        if (closeException == null) {
+            LOG.info("Closed NATS JetStream sink writer for subtask {}", subtaskIndex);
+            return;
+        }
+        throw closeException;
+    }
+
+    @Override
+    public Optional<Void> prepareCommit() {
+        return Optional.empty();
+    }
+
+    @Override
+    public void write(SeaTunnelRow element) throws IOException {
+        publish(requestSerializer.serialize(element));
+    }
+
+    static NatsJetStreamRequestSerializer createRequestSerializer(
+            SeaTunnelRowType seaTunnelRowType, ReadonlyConfig pluginConfig) {
+        String defaultSubject =
+                normalizeSubject(pluginConfig.getOptional(NatsJetStreamSinkOptions.SUBJECT));
+        NatsJetStreamMessageFormat format = pluginConfig.get(NatsJetStreamSinkOptions.FORMAT);
+        if (format == NatsJetStreamMessageFormat.JSON) {
+            return NatsJetStreamRequestSerializer.forJson(
+                    defaultSubject, new JsonSerializationSchema(seaTunnelRowType));
+        }
+        return NatsJetStreamRequestSerializer.forNative(
+                defaultSubject,
+                pluginConfig.get(NatsJetStreamSinkOptions.INCLUDE_ROW_KIND_HEADER),
+                NativeFieldMapping.of(
+                        seaTunnelRowType,
+                        pluginConfig.get(NatsJetStreamSinkOptions.NATIVE_FIELDS)));
+    }
+
+    static String normalizeSubject(Optional<String> subject) {
+        return subject.map(String::trim).filter(value -> !value.isEmpty()).orElse(null);
+    }
+
+    private void connect(ReadonlyConfig pluginConfig) throws IOException {
+        Options.Builder builder =
+                Options.builder()
+                        .server(pluginConfig.get(NatsJetStreamSinkOptions.URL))
+                        .connectionTimeout(CONNECT_TIMEOUT);
+
+        Optional<String> username = pluginConfig.getOptional(NatsJetStreamSinkOptions.USERNAME);
+        Optional<String> password = pluginConfig.getOptional(NatsJetStreamSinkOptions.PASSWORD);
+        Optional<String> token = pluginConfig.getOptional(NatsJetStreamSinkOptions.TOKEN);
+        boolean hasUsername = username.map(NatsJetStreamSinkWriter::isNotBlank).orElse(false);
+        boolean hasPassword = password.map(NatsJetStreamSinkWriter::isNotBlank).orElse(false);
+        boolean hasToken = token.map(NatsJetStreamSinkWriter::isNotBlank).orElse(false);
+        if (hasUsername && hasPassword) {
+            builder.userInfo(username.get().trim(), password.get());
+        } else if (hasToken) {
+            builder.token(token.get().toCharArray());
+        }
+
+        try {
+            connection = Nats.connect(builder.build());
+            jetStream = connection.jetStream();
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+            throw new IOException("Interrupted while connecting to NATS JetStream", e);
+        } catch (IOException | RuntimeException e) {
+            IOException failure =
+                    new IOException(
+                            String.format(
+                                    "Failed to connect NATS JetStream sink writer for subtask %d",
+                                    subtaskIndex),
+                            e);
+            closeConnectionQuietly(connection, failure);
+            throw failure;
+        }
+    }
+
+    /**
+     * Best-effort close of a connection that could not be fully initialized. Preserves the current
+     * thread's interrupt status and attaches any close failure as a suppressed exception on the
+     * provided primary failure so the original initialization error remains visible.
+     */
+    private static void closeConnectionQuietly(Connection toClose, IOException primaryFailure) {
+        if (toClose == null) {
+            return;
+        }
+        try {
+            toClose.close();
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+            primaryFailure.addSuppressed(
+                    new IOException("Interrupted while closing NATS connection", e));
+        } catch (Exception e) {
+            primaryFailure.addSuppressed(new IOException("Failed to close NATS connection", e));
+        }
+    }
+
+    private void publish(PublishRequest publishRequest) throws IOException {
+        PublishOptions.Builder optionsBuilder =
+                PublishOptions.builder().streamTimeout(PUBLISH_TIMEOUT);
+        if (publishRequest.messageId != null) {
+            optionsBuilder.messageId(publishRequest.messageId);
+        }
+        try {
+            jetStream.publish(
+                    publishRequest.subject,
+                    publishRequest.headers,
+                    publishRequest.payload,
+                    optionsBuilder.build());
+        } catch (JetStreamApiException e) {
+            throw publishFailure(publishRequest.subject, e);
+        } catch (IOException | RuntimeException e) {
+            throw publishFailure(publishRequest.subject, e);
+        }
+    }
+
+    private IOException publishFailure(String subject, Exception cause) {
+        return new IOException(
+                String.format(
+                        "Failed to publish NATS JetStream message for subtask %d to subject '%s'",
+                        subtaskIndex, subject),
+                cause);
+    }
+
+    private static boolean isNotBlank(String value) {
+        return value != null && !value.trim().isEmpty();
+    }
+
+    static NatsJetStreamConnectorException invalidRecord(String fieldName, String message) {
+        return new NatsJetStreamConnectorException(
+                CommonErrorCodeDeprecated.ILLEGAL_ARGUMENT,
+                "Invalid NATS JetStream record field `" + fieldName + "`: " + message);
+    }
+
+    static final class PublishRequest {
+        private final String subject;
+        private final String messageId;
+        private final Headers headers;
+        private final byte[] payload;
+
+        PublishRequest(String subject, String messageId, Headers headers, byte[] payload) {
+            this.subject = subject;
+            this.messageId = messageId;
+            this.headers = headers;
+            this.payload = payload;
+        }
+
+        String getSubject() {
+            return subject;
+        }
+
+        String getMessageId() {
+            return messageId;
+        }
+
+        Headers getHeaders() {
+            return headers;
+        }
+
+        byte[] getPayload() {
+            return payload;
+        }
+    }
+
+    static final class NativeFieldMapping {
+        final int messageIdFieldIndex;
+        final int subjectFieldIndex;
+        final int headersFieldIndex;
+        final int dataFieldIndex;
+
+        private NativeFieldMapping(
+                int messageIdFieldIndex,
+                int subjectFieldIndex,
+                int headersFieldIndex,
+                int dataFieldIndex) {
+            this.messageIdFieldIndex = messageIdFieldIndex;
+            this.subjectFieldIndex = subjectFieldIndex;
+            this.headersFieldIndex = headersFieldIndex;
+            this.dataFieldIndex = dataFieldIndex;
+        }
+
+        static NativeFieldMapping of(SeaTunnelRowType rowType, Map<String, String> nativeFields) {
+            return new NativeFieldMapping(
+                    resolveFieldIndex(
+                            rowType, nativeFields, NatsJetStreamSinkOptions.NATIVE_MAPPING_ID),
+                    resolveFieldIndex(
+                            rowType, nativeFields, NatsJetStreamSinkOptions.NATIVE_MAPPING_SUBJECT),
+                    resolveFieldIndex(
+                            rowType, nativeFields, NatsJetStreamSinkOptions.NATIVE_MAPPING_HEADERS),
+                    requireFieldIndex(
+                            rowType, nativeFields, NatsJetStreamSinkOptions.NATIVE_MAPPING_DATA));
+        }
+
+        private static int resolveFieldIndex(
+                SeaTunnelRowType rowType, Map<String, String> nativeFields, String mappingKey) {
+            String fieldName = nativeFields.get(mappingKey);
+            if (fieldName == null || fieldName.trim().isEmpty()) {
+                return -1;
+            }
+            return rowType.indexOf(fieldName, false);
+        }
+
+        private static int requireFieldIndex(
+                SeaTunnelRowType rowType, Map<String, String> nativeFields, String mappingKey) {
+            return rowType.indexOf(nativeFields.get(mappingKey), false);
+        }
+    }
+}
diff --git a/seatunnel-connectors-v2/connector-nats-jetstream/src/test/java/org/apache/seatunnel/connectors/seatunnel/natsjetstream/sink/NatsJetStreamRequestSerializerTest.java b/seatunnel-connectors-v2/connector-nats-jetstream/src/test/java/org/apache/seatunnel/connectors/seatunnel/natsjetstream/sink/NatsJetStreamRequestSerializerTest.java
new file mode 100644
index 0000000000..fe6263b313
--- /dev/null
+++ b/seatunnel-connectors-v2/connector-nats-jetstream/src/test/java/org/apache/seatunnel/connectors/seatunnel/natsjetstream/sink/NatsJetStreamRequestSerializerTest.java
@@ -0,0 +1,267 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.seatunnel.connectors.seatunnel.natsjetstream.sink;
+
+import org.apache.seatunnel.api.configuration.ReadonlyConfig;
+import org.apache.seatunnel.api.table.type.BasicType;
+import org.apache.seatunnel.api.table.type.MapType;
+import org.apache.seatunnel.api.table.type.PrimitiveByteArrayType;
+import org.apache.seatunnel.api.table.type.SeaTunnelDataType;
+import org.apache.seatunnel.api.table.type.SeaTunnelRow;
+import org.apache.seatunnel.api.table.type.SeaTunnelRowType;
+import org.apache.seatunnel.connectors.seatunnel.natsjetstream.config.NatsJetStreamMessageFormat;
+import org.apache.seatunnel.connectors.seatunnel.natsjetstream.config.NatsJetStreamSinkOptions;
+import org.apache.seatunnel.connectors.seatunnel.natsjetstream.exception.NatsJetStreamConnectorException;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.nio.charset.StandardCharsets;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+class NatsJetStreamRequestSerializerTest {
+
+    private static final SeaTunnelRowType JSON_ROW_TYPE =
+            new SeaTunnelRowType(
+                    new String[] {"id", "name", "active"},
+                    new SeaTunnelDataType<?>[] {
+                        BasicType.INT_TYPE, BasicType.STRING_TYPE, BasicType.BOOLEAN_TYPE
+                    });
+
+    static final SeaTunnelRowType NATIVE_ROW_TYPE =
+            new SeaTunnelRowType(
+                    new String[] {"dynamic_subject", "message_id", "attributes", "payload"},
+                    new SeaTunnelDataType<?>[] {
+                        BasicType.STRING_TYPE,
+                        BasicType.STRING_TYPE,
+                        new MapType<>(BasicType.STRING_TYPE, BasicType.STRING_TYPE),
+                        PrimitiveByteArrayType.INSTANCE
+                    });
+
+    @Test
+    void createJsonSerializerGeneratesRepresentativeJsonPayload() {
+        NatsJetStreamRequestSerializer serializer =
+                NatsJetStreamSinkWriter.createRequestSerializer(
+                        JSON_ROW_TYPE, ReadonlyConfig.fromMap(validJsonConfig()));
+
+        NatsJetStreamSinkWriter.PublishRequest request =
+                serializer.serialize(new SeaTunnelRow(new Object[] {7, "alice", true}));
+
+        Assertions.assertEquals("orders.events", request.getSubject());
+        Assertions.assertNull(request.getHeaders());
+        Assertions.assertNull(request.getMessageId());
+        Assertions.assertEquals(
+                "{\"id\":7,\"name\":\"alice\",\"active\":true}",
+                new String(request.getPayload(), StandardCharsets.UTF_8));
+    }
+
+    @Test
+    void createNativeSerializerBuildsSubjectHeadersPayloadAndMessageId() {
+        NatsJetStreamRequestSerializer serializer =
+                NatsJetStreamSinkWriter.createRequestSerializer(
+                        NATIVE_ROW_TYPE, ReadonlyConfig.fromMap(validNativeConfig()));
+
+        Map<String, String> headers = new LinkedHashMap<>();
+        headers.put("tenant", "acme");
+        headers.put("trace", "t-1");
+        byte[] payload = "hello".getBytes(StandardCharsets.UTF_8);
+        SeaTunnelRow row =
+                new SeaTunnelRow(new Object[] {"payments.created", "msg-1", headers, payload});
+
+        NatsJetStreamSinkWriter.PublishRequest request = serializer.serialize(row);
+
+        Assertions.assertEquals("payments.created", request.getSubject());
+        Assertions.assertEquals("msg-1", request.getMessageId());
+        Assertions.assertArrayEquals(payload, request.getPayload());
+        Assertions.assertNotNull(request.getHeaders());
+        Assertions.assertEquals("acme", request.getHeaders().getFirst("tenant"));
+        Assertions.assertEquals("t-1", request.getHeaders().getFirst("trace"));
+        Assertions.assertEquals(
+                "INSERT",
+                request.getHeaders().getFirst(NatsJetStreamRequestSerializer.ROW_KIND_HEADER));
+    }
+
+    @Test
+    void createNativeSerializerFallsBackToConfiguredSubjectAndOptionalFields() {
+        Map<String, Object> config = validNativeConfig();
+        Map<String, String> mappings = new HashMap<>();
+        mappings.put(NatsJetStreamSinkOptions.NATIVE_MAPPING_DATA, "payload");
+        config.put(NatsJetStreamSinkOptions.NATIVE_FIELDS.key(), mappings);
+
+        NatsJetStreamRequestSerializer serializer =
+                NatsJetStreamSinkWriter.createRequestSerializer(
+                        NATIVE_ROW_TYPE, ReadonlyConfig.fromMap(config));
+
+        byte[] payload = "hello".getBytes(StandardCharsets.UTF_8);
+        NatsJetStreamSinkWriter.PublishRequest request =
+                serializer.serialize(new SeaTunnelRow(new Object[] {null, null, null, payload}));
+
+        Assertions.assertEquals("orders.events", request.getSubject());
+        Assertions.assertNull(request.getMessageId());
+        Assertions.assertNotNull(request.getHeaders());
+        Assertions.assertEquals(
+                "INSERT",
+                request.getHeaders().getFirst(NatsJetStreamRequestSerializer.ROW_KIND_HEADER));
+        Assertions.assertArrayEquals(payload, request.getPayload());
+    }
+
+    @Test
+    void createNativeSerializerSkipsRowKindHeaderWhenDisabled() {
+        Map<String, Object> config = validNativeConfig();
+        config.put(NatsJetStreamSinkOptions.INCLUDE_ROW_KIND_HEADER.key(), false);
+
+        NatsJetStreamRequestSerializer serializer =
+                NatsJetStreamSinkWriter.createRequestSerializer(
+                        NATIVE_ROW_TYPE, ReadonlyConfig.fromMap(config));
+
+        NatsJetStreamSinkWriter.PublishRequest request =
+                serializer.serialize(
+                        new SeaTunnelRow(
+                                new Object[] {"payments.created", null, null, bytes("hello")}));
+
+        Assertions.assertNull(request.getHeaders());
+    }
+
+    @Test
+    void createNativeSerializerRejectsBlankSubjectWithoutFallback() {
+        Map<String, Object> config = validNativeConfig();
+        config.remove(NatsJetStreamSinkOptions.SUBJECT.key());
+
+        NatsJetStreamRequestSerializer serializer =
+                NatsJetStreamSinkWriter.createRequestSerializer(
+                        NATIVE_ROW_TYPE, ReadonlyConfig.fromMap(config));
+
+        NatsJetStreamConnectorException exception =
+                Assertions.assertThrows(
+                        NatsJetStreamConnectorException.class,
+                        () ->
+                                serializer.serialize(
+                                        new SeaTunnelRow(
+                                                new Object[] {"   ", null, null, bytes("x")})));
+
+        Assertions.assertTrue(exception.getMessage().contains("field `subject`"));
+        Assertions.assertTrue(exception.getMessage().contains("must not be null or blank"));
+    }
+
+    @Test
+    void createNativeSerializerRejectsWrongSubjectType() {
+        NatsJetStreamRequestSerializer serializer =
+                NatsJetStreamSinkWriter.createRequestSerializer(
+                        NATIVE_ROW_TYPE, ReadonlyConfig.fromMap(validNativeConfig()));
+
+        NatsJetStreamConnectorException exception =
+                Assertions.assertThrows(
+                        NatsJetStreamConnectorException.class,
+                        () ->
+                                serializer.serialize(
+                                        new SeaTunnelRow(
+                                                new Object[] {1, null, null, bytes("x")})));
+
+        Assertions.assertTrue(exception.getMessage().contains("field `subject`"));
+        Assertions.assertTrue(exception.getMessage().contains("STRING value"));
+    }
+
+    @Test
+    void createNativeSerializerRejectsWrongMessageIdType() {
+        NatsJetStreamRequestSerializer serializer =
+                NatsJetStreamSinkWriter.createRequestSerializer(
+                        NATIVE_ROW_TYPE, ReadonlyConfig.fromMap(validNativeConfig()));
+
+        NatsJetStreamConnectorException exception =
+                Assertions.assertThrows(
+                        NatsJetStreamConnectorException.class,
+                        () ->
+                                serializer.serialize(
+                                        new SeaTunnelRow(
+                                                new Object[] {
+                                                    "payments.created", 12, null, bytes("x")
+                                                })));
+
+        Assertions.assertTrue(exception.getMessage().contains("field `id`"));
+        Assertions.assertTrue(exception.getMessage().contains("STRING value"));
+    }
+
+    @Test
+    void createNativeSerializerRejectsWrongHeadersValueType() {
+        NatsJetStreamRequestSerializer serializer =
+                NatsJetStreamSinkWriter.createRequestSerializer(
+                        NATIVE_ROW_TYPE, ReadonlyConfig.fromMap(validNativeConfig()));
+
+        Map<String, Object> headers = new LinkedHashMap<>();
+        headers.put("tenant", 1);
+
+        NatsJetStreamConnectorException exception =
+                Assertions.assertThrows(
+                        NatsJetStreamConnectorException.class,
+                        () ->
+                                serializer.serialize(
+                                        new SeaTunnelRow(
+                                                new Object[] {
+                                                    "payments.created", "msg-1", headers, bytes("x")
+                                                })));
+
+        Assertions.assertTrue(exception.getMessage().contains("field `headers`"));
+        Assertions.assertTrue(exception.getMessage().contains("non-string value"));
+    }
+
+    @Test
+    void createNativeSerializerRejectsWrongPayloadType() {
+        NatsJetStreamRequestSerializer serializer =
+                NatsJetStreamSinkWriter.createRequestSerializer(
+                        NATIVE_ROW_TYPE, ReadonlyConfig.fromMap(validNativeConfig()));
+
+        NatsJetStreamConnectorException exception =
+                Assertions.assertThrows(
+                        NatsJetStreamConnectorException.class,
+                        () ->
+                                serializer.serialize(
+                                        new SeaTunnelRow(
+                                                new Object[] {
+                                                    "payments.created", "msg-1", null, "text"
+                                                })));
+
+        Assertions.assertTrue(exception.getMessage().contains("field `data`"));
+        Assertions.assertTrue(exception.getMessage().contains("non-null BYTES value"));
+    }
+
+    private Map<String, Object> validJsonConfig() {
+        Map<String, Object> config = new HashMap<>();
+        config.put(NatsJetStreamSinkOptions.URL.key(), "nats://127.0.0.1:4222");
+        config.put(NatsJetStreamSinkOptions.SUBJECT.key(), "orders.events");
+        config.put(NatsJetStreamSinkOptions.FORMAT.key(), NatsJetStreamMessageFormat.JSON.name());
+        return config;
+    }
+
+    private Map<String, Object> validNativeConfig() {
+        Map<String, Object> config = validJsonConfig();
+        config.put(NatsJetStreamSinkOptions.FORMAT.key(), NatsJetStreamMessageFormat.NATIVE.name());
+        Map<String, String> mappings = new HashMap<>();
+        mappings.put(NatsJetStreamSinkOptions.NATIVE_MAPPING_SUBJECT, "dynamic_subject");
+        mappings.put(NatsJetStreamSinkOptions.NATIVE_MAPPING_ID, "message_id");
+        mappings.put(NatsJetStreamSinkOptions.NATIVE_MAPPING_HEADERS, "attributes");
+        mappings.put(NatsJetStreamSinkOptions.NATIVE_MAPPING_DATA, "payload");
+        config.put(NatsJetStreamSinkOptions.NATIVE_FIELDS.key(), mappings);
+        return config;
+    }
+
+    private byte[] bytes(String value) {
+        return value.getBytes(StandardCharsets.UTF_8);
+    }
+}
diff --git a/seatunnel-connectors-v2/connector-nats-jetstream/src/test/java/org/apache/seatunnel/connectors/seatunnel/natsjetstream/sink/NatsJetStreamSinkFactoryTest.java b/seatunnel-connectors-v2/connector-nats-jetstream/src/test/java/org/apache/seatunnel/connectors/seatunnel/natsjetstream/sink/NatsJetStreamSinkFactoryTest.java
new file mode 100644
index 0000000000..3056f72798
--- /dev/null
+++ b/seatunnel-connectors-v2/connector-nats-jetstream/src/test/java/org/apache/seatunnel/connectors/seatunnel/natsjetstream/sink/NatsJetStreamSinkFactoryTest.java
@@ -0,0 +1,350 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.seatunnel.connectors.seatunnel.natsjetstream.sink;
+
+import org.apache.seatunnel.api.configuration.ReadonlyConfig;
+import org.apache.seatunnel.api.table.catalog.CatalogTable;
+import org.apache.seatunnel.api.table.catalog.Column;
+import org.apache.seatunnel.api.table.catalog.PhysicalColumn;
+import org.apache.seatunnel.api.table.catalog.TableIdentifier;
+import org.apache.seatunnel.api.table.catalog.TableSchema;
+import org.apache.seatunnel.api.table.factory.TableSinkFactoryContext;
+import org.apache.seatunnel.api.table.type.BasicType;
+import org.apache.seatunnel.api.table.type.MapType;
+import org.apache.seatunnel.api.table.type.PrimitiveByteArrayType;
+import org.apache.seatunnel.connectors.seatunnel.natsjetstream.config.NatsJetStreamMessageFormat;
+import org.apache.seatunnel.connectors.seatunnel.natsjetstream.config.NatsJetStreamSinkOptions;
+import org.apache.seatunnel.connectors.seatunnel.natsjetstream.exception.NatsJetStreamConnectorException;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+class NatsJetStreamSinkFactoryTest {
+
+    private final NatsJetStreamSinkFactory factory = new NatsJetStreamSinkFactory();
+
+    @Test
+    void optionRuleAndFactoryIdentifier() {
+        Assertions.assertNotNull(factory.optionRule());
+        Assertions.assertEquals(
+                NatsJetStreamSinkOptions.CONNECTOR_IDENTITY, factory.factoryIdentifier());
+    }
+
+    @Test
+    void createSinkRejectsBlankUrl() {
+        Map<String, Object> config = validJsonConfig();
+        config.put(NatsJetStreamSinkOptions.URL.key(), "   ");
+
+        assertInvalidOption(config, defaultCatalogTable(), "url", "must not be blank");
+    }
+
+    @Test
+    void createSinkRejectsBlankJsonSubject() {
+        Map<String, Object> config = validJsonConfig();
+        config.put(NatsJetStreamSinkOptions.SUBJECT.key(), "   ");
+
+        assertInvalidOption(config, defaultCatalogTable(), "subject", "must not be blank");
+    }
+
+    @Test
+    void createSinkAcceptsValidJsonConfig() {
+        Assertions.assertDoesNotThrow(() -> createSink(validJsonConfig(), defaultCatalogTable()));
+    }
+
+    @Test
+    void createSinkRejectsMissingUrl() {
+        Map<String, Object> config = validJsonConfig();
+        config.remove(NatsJetStreamSinkOptions.URL.key());
+
+        assertInvalidOption(config, defaultCatalogTable(), "url", "must not be blank");
+    }
+
+    @Test
+    void createSinkRejectsMissingJsonSubject() {
+        Map<String, Object> config = validJsonConfig();
+        config.remove(NatsJetStreamSinkOptions.SUBJECT.key());
+
+        assertInvalidOption(config, defaultCatalogTable(), "subject", "must not be blank");
+    }
+
+    @Test
+    void createSinkRejectsIncompleteUsernamePasswordPair() {
+        Map<String, Object> config = validJsonConfig();
+        config.put(NatsJetStreamSinkOptions.USERNAME.key(), "alice");
+
+        assertInvalidOption(
+                config, defaultCatalogTable(), "password", "must be configured together");
+    }
+
+    @Test
+    void createSinkRejectsConflictingAuthentication() {
+        Map<String, Object> config = validJsonConfig();
+        config.put(NatsJetStreamSinkOptions.USERNAME.key(), "alice");
+        config.put(NatsJetStreamSinkOptions.PASSWORD.key(), "secret");
+        config.put(NatsJetStreamSinkOptions.TOKEN.key(), "token");
+
+        assertInvalidOption(
+                config, defaultCatalogTable(), "token", "cannot be configured together");
+    }
+
+    @Test
+    void createSinkRejectsUnknownFormatValue() {
+        Map<String, Object> config = validJsonConfig();
+        config.put(NatsJetStreamSinkOptions.FORMAT.key(), "yaml");
+
+        Assertions.assertThrows(
+                IllegalArgumentException.class, () -> createSink(config, defaultCatalogTable()));
+    }
+
+    @Test
+    void createSinkRejectsNativeWithoutDataMapping() {
+        Map<String, Object> config = validNativeConfig();
+        config.put(NatsJetStreamSinkOptions.NATIVE_FIELDS.key(), new HashMap<String, String>());
+
+        assertInvalidOption(
+                config,
+                defaultCatalogTable(),
+                NatsJetStreamSinkOptions.NATIVE_FIELDS.key(),
+                "must define at least the `data` field mapping");
+    }
+
+    @Test
+    void createSinkRejectsNativeWithoutSubjectFallbackOrMapping() {
+        Map<String, Object> config = validNativeConfig();
+        config.remove(NatsJetStreamSinkOptions.SUBJECT.key());
+        Map<String, String> mappings = new HashMap<>();
+        mappings.put(NatsJetStreamSinkOptions.NATIVE_MAPPING_DATA, "payload");
+        config.put(NatsJetStreamSinkOptions.NATIVE_FIELDS.key(), mappings);
+
+        assertInvalidOption(config, defaultCatalogTable(), "subject", "must be configured");
+    }
+
+    @Test
+    void createSinkRejectsNativeSubjectMappingToMissingFieldWithoutFallback() {
+        Map<String, Object> config = validNativeConfig();
+        config.remove(NatsJetStreamSinkOptions.SUBJECT.key());
+        Map<String, String> mappings = new HashMap<>();
+        mappings.put(NatsJetStreamSinkOptions.NATIVE_MAPPING_DATA, "payload");
+        mappings.put(NatsJetStreamSinkOptions.NATIVE_MAPPING_SUBJECT, "missing_subject");
+        config.put(NatsJetStreamSinkOptions.NATIVE_FIELDS.key(), mappings);
+
+        assertInvalidField(
+                config, defaultCatalogTable(), "missing_subject", "does not exist in table schema");
+    }
+
+    @Test
+    void createSinkAcceptsNativeSubjectMappingToMissingFieldWithFallback() {
+        Map<String, Object> config = validNativeConfig();
+        Map<String, String> mappings = new HashMap<>();
+        mappings.put(NatsJetStreamSinkOptions.NATIVE_MAPPING_DATA, "payload");
+        mappings.put(NatsJetStreamSinkOptions.NATIVE_MAPPING_SUBJECT, "missing_subject");
+        config.put(NatsJetStreamSinkOptions.NATIVE_FIELDS.key(), mappings);
+
+        Assertions.assertDoesNotThrow(() -> createSink(config, defaultCatalogTable()));
+    }
+
+    @Test
+    void createSinkRejectsNativeMissingMappedPayloadField() {
+        Map<String, Object> config = validNativeConfig();
+        Map<String, String> mappings = new HashMap<>();
+        mappings.put(NatsJetStreamSinkOptions.NATIVE_MAPPING_DATA, "missing_payload");
+        mappings.put(NatsJetStreamSinkOptions.NATIVE_MAPPING_SUBJECT, "dynamic_subject");
+        config.put(NatsJetStreamSinkOptions.NATIVE_FIELDS.key(), mappings);
+
+        assertInvalidField(
+                config, defaultCatalogTable(), "missing_payload", "does not exist in table schema");
+    }
+
+    @Test
+    void createSinkRejectsNativeWrongPayloadType() {
+        Map<String, Object> config = validNativeConfig();
+        Map<String, String> mappings = new HashMap<>();
+        mappings.put(NatsJetStreamSinkOptions.NATIVE_MAPPING_DATA, "dynamic_subject");
+        config.put(NatsJetStreamSinkOptions.NATIVE_FIELDS.key(), mappings);
+
+        assertInvalidField(
+                config, defaultCatalogTable(), "dynamic_subject", "must use `BYTES` type");
+    }
+
+    @Test
+    void createSinkRejectsNativeWrongSubjectType() {
+        Map<String, Object> config = validNativeConfig();
+        Map<String, String> mappings = new HashMap<>();
+        mappings.put(NatsJetStreamSinkOptions.NATIVE_MAPPING_DATA, "payload");
+        mappings.put(NatsJetStreamSinkOptions.NATIVE_MAPPING_SUBJECT, "payload");
+        config.put(NatsJetStreamSinkOptions.NATIVE_FIELDS.key(), mappings);
+
+        assertInvalidFieldOrOption(
+                config, defaultCatalogTable(), "payload", "native mapping `subject`");
+    }
+
+    @Test
+    void createSinkRejectsNativeWrongHeadersType() {
+        Map<String, Object> config = validNativeConfig();
+        Map<String, String> mappings = new HashMap<>();
+        mappings.put(NatsJetStreamSinkOptions.NATIVE_MAPPING_DATA, "payload");
+        mappings.put(NatsJetStreamSinkOptions.NATIVE_MAPPING_HEADERS, "dynamic_subject");
+        config.put(NatsJetStreamSinkOptions.NATIVE_FIELDS.key(), mappings);
+
+        assertInvalidField(config, defaultCatalogTable(), "dynamic_subject", "MAP<STRING, STRING>");
+    }
+
+    @Test
+    void createSinkAcceptsNativeCustomFieldMapping() {
+        Map<String, Object> config = validNativeConfig();
+        Map<String, String> mappings = new HashMap<>();
+        mappings.put(NatsJetStreamSinkOptions.NATIVE_MAPPING_DATA, "payload");
+        mappings.put(NatsJetStreamSinkOptions.NATIVE_MAPPING_SUBJECT, "dynamic_subject");
+        mappings.put(NatsJetStreamSinkOptions.NATIVE_MAPPING_HEADERS, "attributes");
+        mappings.put(NatsJetStreamSinkOptions.NATIVE_MAPPING_ID, "message_id");
+        config.put(NatsJetStreamSinkOptions.NATIVE_FIELDS.key(), mappings);
+
+        Assertions.assertDoesNotThrow(() -> createSink(config, defaultCatalogTable()));
+    }
+
+    @Test
+    void createSinkAcceptsNativeDefaultMappingWithOnlyDataField() {
+        Map<String, Object> config = validJsonConfig();
+        config.put(NatsJetStreamSinkOptions.FORMAT.key(), NatsJetStreamMessageFormat.NATIVE.name());
+        Assertions.assertDoesNotThrow(() -> createSink(config, dataOnlyCatalogTable()));
+    }
+
+    private void assertInvalidOption(
+            Map<String, Object> config,
+            CatalogTable catalogTable,
+            String optionKey,
+            String fragment) {
+        NatsJetStreamConnectorException exception =
+                Assertions.assertThrows(
+                        NatsJetStreamConnectorException.class,
+                        () -> createSink(config, catalogTable));
+        Assertions.assertTrue(exception.getMessage().contains("option `" + optionKey + "`"));
+        Assertions.assertTrue(exception.getMessage().contains(fragment));
+    }
+
+    private void assertInvalidField(
+            Map<String, Object> config,
+            CatalogTable catalogTable,
+            String fieldName,
+            String fragment) {
+        NatsJetStreamConnectorException exception =
+                Assertions.assertThrows(
+                        NatsJetStreamConnectorException.class,
+                        () -> createSink(config, catalogTable));
+        Assertions.assertTrue(exception.getMessage().contains("field `" + fieldName + "`"));
+        Assertions.assertTrue(exception.getMessage().contains(fragment));
+    }
+
+    private void assertInvalidFieldOrOption(
+            Map<String, Object> config,
+            CatalogTable catalogTable,
+            String fieldOrOptionName,
+            String fragment) {
+        NatsJetStreamConnectorException exception =
+                Assertions.assertThrows(
+                        NatsJetStreamConnectorException.class,
+                        () -> createSink(config, catalogTable));
+        Assertions.assertTrue(
+                exception.getMessage().contains("field `" + fieldOrOptionName + "`")
+                        || exception.getMessage().contains("option `" + fieldOrOptionName + "`"));
+        Assertions.assertTrue(exception.getMessage().contains(fragment));
+    }
+
+    private void createSink(Map<String, Object> config, CatalogTable catalogTable) {
+        factory.createSink(
+                new TableSinkFactoryContext(
+                        catalogTable, ReadonlyConfig.fromMap(config), getClass().getClassLoader()));
+    }
+
+    private Map<String, Object> validJsonConfig() {
+        Map<String, Object> config = new HashMap<>();
+        config.put(NatsJetStreamSinkOptions.URL.key(), "nats://127.0.0.1:4222");
+        config.put(NatsJetStreamSinkOptions.SUBJECT.key(), "orders.events");
+        config.put(NatsJetStreamSinkOptions.FORMAT.key(), NatsJetStreamMessageFormat.JSON.name());
+        return config;
+    }
+
+    private Map<String, Object> validNativeConfig() {
+        Map<String, Object> config = validJsonConfig();
+        config.put(NatsJetStreamSinkOptions.FORMAT.key(), NatsJetStreamMessageFormat.NATIVE.name());
+        Map<String, String> mappings = new HashMap<>();
+        mappings.put(NatsJetStreamSinkOptions.NATIVE_MAPPING_DATA, "payload");
+        mappings.put(NatsJetStreamSinkOptions.NATIVE_MAPPING_SUBJECT, "dynamic_subject");
+        mappings.put(NatsJetStreamSinkOptions.NATIVE_MAPPING_HEADERS, "attributes");
+        mappings.put(NatsJetStreamSinkOptions.NATIVE_MAPPING_ID, "message_id");
+        config.put(NatsJetStreamSinkOptions.NATIVE_FIELDS.key(), mappings);
+        return config;
+    }
+
+    private CatalogTable dataOnlyCatalogTable() {
+        List<Column> columns = new ArrayList<>();
+        columns.add(
+                PhysicalColumn.builder()
+                        .name("data")
+                        .dataType(PrimitiveByteArrayType.INSTANCE)
+                        .nullable(false)
+                        .build());
+        TableSchema tableSchema = TableSchema.builder().columns(columns).build();
+        return CatalogTable.of(
+                TableIdentifier.of("default", "default", "nats_jetstream_data_only_sink"),
+                tableSchema,
+                new HashMap<>(),
+                new ArrayList<>(),
+                "nats jetstream data only sink test table");
+    }
+
+    private CatalogTable defaultCatalogTable() {
+        List<Column> columns = new ArrayList<>();
+        columns.add(
+                PhysicalColumn.builder()
+                        .name("dynamic_subject")
+                        .dataType(BasicType.STRING_TYPE)
+                        .nullable(true)
+                        .build());
+        columns.add(
+                PhysicalColumn.builder()
+                        .name("message_id")
+                        .dataType(BasicType.STRING_TYPE)
+                        .nullable(true)
+                        .build());
+        columns.add(
+                PhysicalColumn.builder()
+                        .name("attributes")
+                        .dataType(new MapType<>(BasicType.STRING_TYPE, BasicType.STRING_TYPE))
+                        .nullable(true)
+                        .build());
+        columns.add(
+                PhysicalColumn.builder()
+                        .name("payload")
+                        .dataType(PrimitiveByteArrayType.INSTANCE)
+                        .nullable(false)
+                        .build());
+        TableSchema tableSchema = TableSchema.builder().columns(columns).build();
+        return CatalogTable.of(
+                TableIdentifier.of("default", "default", "nats_jetstream_sink"),
+                tableSchema,
+                new HashMap<>(),
+                new ArrayList<>(),
+                "nats jetstream sink test table");
+    }
+}
diff --git a/seatunnel-connectors-v2/connector-nats-jetstream/src/test/java/org/apache/seatunnel/connectors/seatunnel/natsjetstream/sink/NatsJetStreamSinkWriterTest.java b/seatunnel-connectors-v2/connector-nats-jetstream/src/test/java/org/apache/seatunnel/connectors/seatunnel/natsjetstream/sink/NatsJetStreamSinkWriterTest.java
new file mode 100644
index 0000000000..97e80345a9
--- /dev/null
+++ b/seatunnel-connectors-v2/connector-nats-jetstream/src/test/java/org/apache/seatunnel/connectors/seatunnel/natsjetstream/sink/NatsJetStreamSinkWriterTest.java
@@ -0,0 +1,322 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.seatunnel.connectors.seatunnel.natsjetstream.sink;
+
+import org.apache.seatunnel.api.configuration.ReadonlyConfig;
+import org.apache.seatunnel.api.table.type.BasicType;
+import org.apache.seatunnel.api.table.type.PrimitiveByteArrayType;
+import org.apache.seatunnel.api.table.type.SeaTunnelDataType;
+import org.apache.seatunnel.api.table.type.SeaTunnelRow;
+import org.apache.seatunnel.api.table.type.SeaTunnelRowType;
+import org.apache.seatunnel.connectors.seatunnel.natsjetstream.config.NatsJetStreamSinkOptions;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.MockedStatic;
+import org.mockito.Mockito;
+
+import io.nats.client.Connection;
+import io.nats.client.JetStreamApiException;
+import io.nats.client.Nats;
+import io.nats.client.PublishOptions;
+import io.nats.client.impl.Headers;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.util.HashMap;
+import java.util.Map;
+
+class NatsJetStreamSinkWriterTest {
+
+    private static final SeaTunnelRowType JSON_ROW_TYPE =
+            new SeaTunnelRowType(
+                    new String[] {"id", "name"},
+                    new SeaTunnelDataType<?>[] {BasicType.INT_TYPE, BasicType.STRING_TYPE});
+
+    @Test
+    void writePublishesJsonPayload() throws Exception {
+        TestContext context = new TestContext();
+        try (TestWriterResources resources = TestWriterResources.open(context)) {
+            NatsJetStreamSinkWriter writer =
+                    new NatsJetStreamSinkWriter(
+                            context,
+                            JSON_ROW_TYPE,
+                            ReadonlyConfig.fromMap(validJsonConfig()),
+                            TestWriterResources.catalogTable(JSON_ROW_TYPE));
+
+            writer.write(new SeaTunnelRow(new Object[] {1, "alice"}));
+
+            ArgumentCaptor<byte[]> payloadCaptor = ArgumentCaptor.forClass(byte[].class);
+            ArgumentCaptor<PublishOptions> optionsCaptor =
+                    ArgumentCaptor.forClass(PublishOptions.class);
+            Mockito.verify(resources.getJetStream())
+                    .publish(
+                            Mockito.eq("orders.events"),
+                            Mockito.isNull(),
+                            payloadCaptor.capture(),
+                            optionsCaptor.capture());
+            Assertions.assertEquals(
+                    "{\"id\":1,\"name\":\"alice\"}",
+                    new String(payloadCaptor.getValue(), StandardCharsets.UTF_8));
+            Assertions.assertNull(optionsCaptor.getValue().getMessageId());
+        }
+    }
+
+    @Test
+    void writeTranslatesJetStreamPublishFailure() throws Exception {
+        TestContext context = new TestContext();
+        try (TestWriterResources resources = TestWriterResources.open(context)) {
+            Mockito.doThrow(Mockito.mock(JetStreamApiException.class))
+                    .when(resources.getJetStream())
+                    .publish(
+                            Mockito.anyString(),
+                            Mockito.any(),
+                            Mockito.any(byte[].class),
+                            Mockito.any(PublishOptions.class));
+
+            NatsJetStreamSinkWriter writer =
+                    new NatsJetStreamSinkWriter(
+                            context,
+                            JSON_ROW_TYPE,
+                            ReadonlyConfig.fromMap(validJsonConfig()),
+                            TestWriterResources.catalogTable(JSON_ROW_TYPE));
+
+            IOException exception =
+                    Assertions.assertThrows(
+                            IOException.class,
+                            () -> writer.write(new SeaTunnelRow(new Object[] {1, "alice"})));
+
+            Assertions.assertTrue(
+                    exception.getMessage().contains("Failed to publish NATS JetStream message"));
+            Assertions.assertTrue(exception.getMessage().contains("orders.events"));
+        }
+    }
+
+    @Test
+    void closeTranslatesInterruptedExceptionAndPreservesInterrupt() throws Exception {
+        TestContext context = new TestContext();
+        try (TestWriterResources resources = TestWriterResources.open(context)) {
+            Mockito.doThrow(new InterruptedException("stop"))
+                    .when(resources.getConnection())
+                    .close();
+
+            NatsJetStreamSinkWriter writer =
+                    new NatsJetStreamSinkWriter(
+                            context,
+                            JSON_ROW_TYPE,
+                            ReadonlyConfig.fromMap(validJsonConfig()),
+                            TestWriterResources.catalogTable(JSON_ROW_TYPE));
+
+            IOException exception = Assertions.assertThrows(IOException.class, writer::close);
+
+            Assertions.assertTrue(
+                    exception.getMessage().contains("Interrupted while closing NATS connection"));
+            Assertions.assertTrue(Thread.currentThread().isInterrupted());
+            Thread.interrupted();
+        }
+    }
+
+    @Test
+    void writePublishesDeleteRowKindAsRegularMessage() throws Exception {
+        TestContext context = new TestContext();
+        try (TestWriterResources resources = TestWriterResources.open(context)) {
+            NatsJetStreamSinkWriter writer =
+                    new NatsJetStreamSinkWriter(
+                            context,
+                            JSON_ROW_TYPE,
+                            ReadonlyConfig.fromMap(validJsonConfig()),
+                            TestWriterResources.catalogTable(JSON_ROW_TYPE));
+            SeaTunnelRow row = new SeaTunnelRow(new Object[] {1, "alice"});
+            row.setRowKind(org.apache.seatunnel.api.table.type.RowKind.DELETE);
+
+            writer.write(row);
+
+            Mockito.verify(resources.getJetStream())
+                    .publish(
+                            Mockito.eq("orders.events"),
+                            Mockito.isNull(),
+                            Mockito.any(byte[].class),
+                            Mockito.any(PublishOptions.class));
+        }
+    }
+
+    @Test
+    void writePublishesNativeDataOnlyMessageUsingConfiguredSubjectFallback() throws Exception {
+        SeaTunnelRowType dataOnlyRowType =
+                new SeaTunnelRowType(
+                        new String[] {"data"},
+                        new SeaTunnelDataType<?>[] {PrimitiveByteArrayType.INSTANCE});
+        TestContext context = new TestContext();
+        try (TestWriterResources resources = TestWriterResources.open(context)) {
+            NatsJetStreamSinkWriter writer =
+                    new NatsJetStreamSinkWriter(
+                            context,
+                            dataOnlyRowType,
+                            ReadonlyConfig.fromMap(validNativeFallbackConfig()),
+                            TestWriterResources.catalogTable(dataOnlyRowType));
+            byte[] payload = "payload".getBytes(StandardCharsets.UTF_8);
+
+            writer.write(new SeaTunnelRow(new Object[] {payload}));
+
+            ArgumentCaptor<byte[]> payloadCaptor = ArgumentCaptor.forClass(byte[].class);
+            ArgumentCaptor<Headers> headersCaptor = ArgumentCaptor.forClass(Headers.class);
+            Mockito.verify(resources.getJetStream())
+                    .publish(
+                            Mockito.eq("orders.events"),
+                            headersCaptor.capture(),
+                            payloadCaptor.capture(),
+                            Mockito.any(PublishOptions.class));
+            Assertions.assertArrayEquals(payload, payloadCaptor.getValue());
+            Assertions.assertEquals(
+                    "INSERT",
+                    headersCaptor
+                            .getValue()
+                            .getFirst(NatsJetStreamRequestSerializer.ROW_KIND_HEADER));
+        }
+    }
+
+    @Test
+    void writePublishesNativeMessageIdAndHeaders() throws Exception {
+        SeaTunnelRowType nativeRowType = NatsJetStreamRequestSerializerTest.NATIVE_ROW_TYPE;
+        TestContext context = new TestContext();
+        try (TestWriterResources resources = TestWriterResources.open(context)) {
+            NatsJetStreamSinkWriter writer =
+                    new NatsJetStreamSinkWriter(
+                            context,
+                            nativeRowType,
+                            ReadonlyConfig.fromMap(validNativeConfig()),
+                            TestWriterResources.catalogTable(nativeRowType));
+
+            Map<String, String> headers = new HashMap<>();
+            headers.put("tenant", "acme");
+            headers.put("trace", "t-1");
+            writer.write(
+                    new SeaTunnelRow(
+                            new Object[] {
+                                "payments.created",
+                                "message-9",
+                                headers,
+                                "payload".getBytes(StandardCharsets.UTF_8)
+                            }));
+
+            ArgumentCaptor<Headers> headersCaptor = ArgumentCaptor.forClass(Headers.class);
+            ArgumentCaptor<PublishOptions> optionsCaptor =
+                    ArgumentCaptor.forClass(PublishOptions.class);
+            Mockito.verify(resources.getJetStream())
+                    .publish(
+                            Mockito.eq("payments.created"),
+                            headersCaptor.capture(),
+                            Mockito.any(byte[].class),
+                            optionsCaptor.capture());
+            Assertions.assertEquals("acme", headersCaptor.getValue().getFirst("tenant"));
+            Assertions.assertEquals("message-9", optionsCaptor.getValue().getMessageId());
+            Assertions.assertEquals(
+                    "INSERT",
+                    headersCaptor
+                            .getValue()
+                            .getFirst(NatsJetStreamRequestSerializer.ROW_KIND_HEADER));
+        }
+    }
+
+    @Test
+    void writeSkipsRowKindHeaderWhenDisabled() throws Exception {
+        SeaTunnelRowType nativeRowType = NatsJetStreamRequestSerializerTest.NATIVE_ROW_TYPE;
+        TestContext context = new TestContext();
+        try (TestWriterResources resources = TestWriterResources.open(context)) {
+            Map<String, Object> config = validNativeConfig();
+            config.put(NatsJetStreamSinkOptions.INCLUDE_ROW_KIND_HEADER.key(), false);
+            NatsJetStreamSinkWriter writer =
+                    new NatsJetStreamSinkWriter(
+                            context,
+                            nativeRowType,
+                            ReadonlyConfig.fromMap(config),
+                            TestWriterResources.catalogTable(nativeRowType));
+
+            writer.write(
+                    new SeaTunnelRow(
+                            new Object[] {
+                                "payments.created",
+                                "message-9",
+                                null,
+                                "payload".getBytes(StandardCharsets.UTF_8)
+                            }));
+
+            Mockito.verify(resources.getJetStream())
+                    .publish(
+                            Mockito.eq("payments.created"),
+                            Mockito.isNull(),
+                            Mockito.any(byte[].class),
+                            Mockito.any(PublishOptions.class));
+        }
+    }
+
+    @Test
+    void constructorClosesConnectionWhenJetStreamAcquisitionFails() throws Exception {
+        TestContext context = new TestContext();
+        Connection connection = Mockito.mock(Connection.class);
+        Mockito.when(connection.jetStream())
+                .thenThrow(new RuntimeException("jetStream unavailable"));
+        try (MockedStatic<Nats> mockedNats = Mockito.mockStatic(Nats.class)) {
+            mockedNats
+                    .when(() -> Nats.connect(Mockito.any(io.nats.client.Options.class)))
+                    .thenReturn(connection);
+
+            IOException exception =
+                    Assertions.assertThrows(
+                            IOException.class,
+                            () ->
+                                    new NatsJetStreamSinkWriter(
+                                            context,
+                                            JSON_ROW_TYPE,
+                                            ReadonlyConfig.fromMap(validJsonConfig()),
+                                            TestWriterResources.catalogTable(JSON_ROW_TYPE)));
+
+            Assertions.assertTrue(
+                    exception
+                            .getMessage()
+                            .contains("Failed to connect NATS JetStream sink writer"));
+        }
+        Mockito.verify(connection, Mockito.times(1)).close();
+    }
+
+    private Map<String, Object> validJsonConfig() {
+        Map<String, Object> config = new HashMap<>();
+        config.put(NatsJetStreamSinkOptions.URL.key(), "nats://127.0.0.1:4222");
+        config.put(NatsJetStreamSinkOptions.SUBJECT.key(), "orders.events");
+        return config;
+    }
+
+    private Map<String, Object> validNativeFallbackConfig() {
+        Map<String, Object> config = validJsonConfig();
+        config.put(NatsJetStreamSinkOptions.FORMAT.key(), "NATIVE");
+        return config;
+    }
+
+    private Map<String, Object> validNativeConfig() {
+        Map<String, Object> config = validJsonConfig();
+        config.put(NatsJetStreamSinkOptions.FORMAT.key(), "NATIVE");
+        Map<String, String> mappings = new HashMap<>();
+        mappings.put(NatsJetStreamSinkOptions.NATIVE_MAPPING_SUBJECT, "dynamic_subject");
+        mappings.put(NatsJetStreamSinkOptions.NATIVE_MAPPING_ID, "message_id");
+        mappings.put(NatsJetStreamSinkOptions.NATIVE_MAPPING_HEADERS, "attributes");
+        mappings.put(NatsJetStreamSinkOptions.NATIVE_MAPPING_DATA, "payload");
+        config.put(NatsJetStreamSinkOptions.NATIVE_FIELDS.key(), mappings);
+        return config;
+    }
+}
diff --git a/seatunnel-connectors-v2/connector-nats-jetstream/src/test/java/org/apache/seatunnel/connectors/seatunnel/natsjetstream/sink/TestContext.java b/seatunnel-connectors-v2/connector-nats-jetstream/src/test/java/org/apache/seatunnel/connectors/seatunnel/natsjetstream/sink/TestContext.java
new file mode 100644
index 0000000000..bda2d0afb5
--- /dev/null
+++ b/seatunnel-connectors-v2/connector-nats-jetstream/src/test/java/org/apache/seatunnel/connectors/seatunnel/natsjetstream/sink/TestContext.java
@@ -0,0 +1,40 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.seatunnel.connectors.seatunnel.natsjetstream.sink;
+
+import org.apache.seatunnel.api.common.metrics.MetricsContext;
+import org.apache.seatunnel.api.event.EventListener;
+import org.apache.seatunnel.api.sink.SinkWriter;
+
+final class TestContext implements SinkWriter.Context {
+
+    @Override
+    public int getIndexOfSubtask() {
+        return 2;
+    }
+
+    @Override
+    public MetricsContext getMetricsContext() {
+        return null;
+    }
+
+    @Override
+    public EventListener getEventListener() {
+        return null;
+    }
+}
diff --git a/seatunnel-connectors-v2/connector-nats-jetstream/src/test/java/org/apache/seatunnel/connectors/seatunnel/natsjetstream/sink/TestWriterResources.java b/seatunnel-connectors-v2/connector-nats-jetstream/src/test/java/org/apache/seatunnel/connectors/seatunnel/natsjetstream/sink/TestWriterResources.java
new file mode 100644
index 0000000000..918482d013
--- /dev/null
+++ b/seatunnel-connectors-v2/connector-nats-jetstream/src/test/java/org/apache/seatunnel/connectors/seatunnel/natsjetstream/sink/TestWriterResources.java
@@ -0,0 +1,94 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.seatunnel.connectors.seatunnel.natsjetstream.sink;
+
+import org.apache.seatunnel.api.table.catalog.CatalogTable;
+import org.apache.seatunnel.api.table.catalog.Column;
+import org.apache.seatunnel.api.table.catalog.PhysicalColumn;
+import org.apache.seatunnel.api.table.catalog.TableIdentifier;
+import org.apache.seatunnel.api.table.catalog.TableSchema;
+import org.apache.seatunnel.api.table.type.SeaTunnelDataType;
+import org.apache.seatunnel.api.table.type.SeaTunnelRowType;
+
+import org.mockito.MockedStatic;
+import org.mockito.Mockito;
+
+import io.nats.client.Connection;
+import io.nats.client.JetStream;
+import io.nats.client.Nats;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+final class TestWriterResources implements AutoCloseable {
+
+    private final MockedStatic<Nats> mockedNats;
+    private final Connection connection;
+    private final JetStream jetStream;
+
+    private TestWriterResources(
+            MockedStatic<Nats> mockedNats, Connection connection, JetStream jetStream) {
+        this.mockedNats = mockedNats;
+        this.connection = connection;
+        this.jetStream = jetStream;
+    }
+
+    static TestWriterResources open(TestContext context) throws Exception {
+        Connection connection = Mockito.mock(Connection.class);
+        JetStream jetStream = Mockito.mock(JetStream.class);
+        Mockito.when(connection.jetStream()).thenReturn(jetStream);
+        MockedStatic<Nats> mockedNats = Mockito.mockStatic(Nats.class);
+        mockedNats
+                .when(() -> Nats.connect(Mockito.any(io.nats.client.Options.class)))
+                .thenReturn(connection);
+        return new TestWriterResources(mockedNats, connection, jetStream);
+    }
+
+    static CatalogTable catalogTable(SeaTunnelRowType rowType) {
+        List<Column> columns = new ArrayList<>();
+        for (int i = 0; i < rowType.getTotalFields(); i++) {
+            SeaTunnelDataType<?> fieldType = rowType.getFieldType(i);
+            columns.add(
+                    PhysicalColumn.builder()
+                            .name(rowType.getFieldName(i))
+                            .dataType(fieldType)
+                            .nullable(true)
+                            .build());
+        }
+        return CatalogTable.of(
+                TableIdentifier.of("default", "default", "nats_test"),
+                TableSchema.builder().columns(columns).build(),
+                new HashMap<>(),
+                new ArrayList<>(),
+                "nats test table");
+    }
+
+    Connection getConnection() {
+        return connection;
+    }
+
+    JetStream getJetStream() {
+        return jetStream;
+    }
+
+    @Override
+    public void close() {
+        mockedNats.close();
+    }
+}
diff --git a/seatunnel-connectors-v2/pom.xml b/seatunnel-connectors-v2/pom.xml
index bb47dfb588..b4ad18b799 100644
--- a/seatunnel-connectors-v2/pom.xml
+++ b/seatunnel-connectors-v2/pom.xml
@@ -96,6 +96,7 @@
         <module>connector-lance</module>
         <module>connector-bigquery</module>
         <module>connector-edge-socket</module>
+        <module>connector-nats-jetstream</module>
     </modules>
 
     <dependencyManagement>
diff --git a/seatunnel-dist/pom.xml b/seatunnel-dist/pom.xml
index 38fdf57ff5..160570b5b5 100644
--- a/seatunnel-dist/pom.xml
+++ b/seatunnel-dist/pom.xml
@@ -779,6 +779,13 @@
                     <scope>provided</scope>
                 </dependency>
 
+                <dependency>
+                    <groupId>org.apache.seatunnel</groupId>
+                    <artifactId>connector-nats-jetstream</artifactId>
+                    <version>${project.version}</version>
+                    <scope>provided</scope>
+                </dependency>
+
                 <dependency>
                     <groupId>org.apache.seatunnel</groupId>
                     <artifactId>connector-bigquery</artifactId>
diff --git a/seatunnel-dist/release-docs/LICENSE b/seatunnel-dist/release-docs/LICENSE
index 230037dded..19f4983a9b 100644
--- a/seatunnel-dist/release-docs/LICENSE
+++ b/seatunnel-dist/release-docs/LICENSE
@@ -338,7 +338,10 @@ The text of each license is the standard Apache 2.0 license.
      (The Apache Software License, Version 2.0) Prometheus Java Span Context Supplier - OpenTelemetry (io.prometheus:simpleclient_tracer_otel:0.16.0 - https://mvnrepository.com/artifact/io.prometheus/simpleclient_tracer_otel/0.16.0)
      (The Apache Software License, Version 2.0) Prometheus Java Span Context Supplier - OpenTelemetry Agent (io.prometheus:simpleclient_tracer_otel_agent:0.16.0 - https://mvnrepository.com/artifact/io.prometheus/simpleclient_tracer_otel_agent/0.16.0)
      (Apache-2.0) hugegraph-client (org.apache.hugegraph:hugegraph-client:1.5.0 - https://github.com/apache/incubator-hugegraph-toolchain/tree/master/hugegraph-client)
-     (Apache-2.0) hugegraph-common (org.apache.hugegraph:hugegraph-common:1.5.0 - https://github.com/apache/incubator-hugegraph-commons/tree/master/hugegraph-common)
+      (Apache-2.0) hugegraph-common (org.apache.hugegraph:hugegraph-common:1.5.0 - https://github.com/apache/incubator-hugegraph-commons/tree/master/hugegraph-common)
+      (Apache-2.0) jnats (io.nats:jnats:2.24.0 - https://github.com/nats-io/nats.java)
+      (Apache-2.0) jspecify (org.jspecify:jspecify:1.0.0 - https://github.com/jspecify/jspecify)
+
 
 ========================================================================
 MOZILLA PUBLIC LICENSE License
@@ -403,7 +406,9 @@ The text of each license is also included at licenses/LICENSE-[project].txt.
      (MIT License) jcl-over-slf4j (org.slf4j:jcl-over-slf4j:1.7.25 - http://www.slf4j.org)
      (MIT License) animal-sniffer-annotations (org.codehaus.mojo:animal-sniffer-annotations:1.17 - https://mvnrepository.com/artifact/org.codehaus.mojo/animal-sniffer-annotations/1.17)
      (MIT License) checker-qual (org.checkerframework:checker-qual:3.10.0 - https://mvnrepository.com/)
-     (MIT License) oshi-core (com.github.oshi:oshi-core:6.6.5 - https://github.com/oshi/oshi)
+      (MIT License) oshi-core (com.github.oshi:oshi-core:6.6.5 - https://github.com/oshi/oshi)
+      (MIT License) Bouncy Castle Provider (LTS Distribution) (org.bouncycastle:bcprov-lts8on:2.73.9 - https://www.bouncycastle.org/lts-java)
+
 
 ========================================================================
 EPL-1.0 and Apache-2.0 licenses
diff --git a/seatunnel-dist/release-docs/NOTICE b/seatunnel-dist/release-docs/NOTICE
index 6dd8daa880..1bc24a56c9 100644
--- a/seatunnel-dist/release-docs/NOTICE
+++ b/seatunnel-dist/release-docs/NOTICE
@@ -1,6 +1,10 @@
 Apache SeaTunnel
 Copyright 2021-2024 The Apache Software Foundation
 
+This product includes Bouncy Castle Provider (LTS Distribution), developed by
+The Legion of the Bouncy Castle Inc. and distributed under the Bouncy Castle
+License. The license text is provided in licenses/LICENSE-bcprov-lts8on.txt.
+
 This product includes software developed at
 The Apache Software Foundation (http://www.apache.org/).
 
diff --git a/seatunnel-dist/release-docs/licenses/LICENSE-bcprov-lts8on.txt b/seatunnel-dist/release-docs/licenses/LICENSE-bcprov-lts8on.txt
new file mode 100644
index 0000000000..30018c1912
--- /dev/null
+++ b/seatunnel-dist/release-docs/licenses/LICENSE-bcprov-lts8on.txt
@@ -0,0 +1,21 @@
+Bouncy Castle License
+
+Copyright (c) 2000-2026 The Legion of the Bouncy Castle Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/seatunnel-dist/release-docs/licenses/LICENSE-jnats.txt b/seatunnel-dist/release-docs/licenses/LICENSE-jnats.txt
new file mode 100644
index 0000000000..3ed6e31751
--- /dev/null
+++ b/seatunnel-dist/release-docs/licenses/LICENSE-jnats.txt
@@ -0,0 +1 @@
+License: {Name: The Apache License, Version 2.0, URL: http://www.apache.org/licenses/LICENSE-2.0.txt, Distribution: repo, Comments: , }
diff --git a/seatunnel-dist/release-docs/licenses/LICENSE-jspecify.txt b/seatunnel-dist/release-docs/licenses/LICENSE-jspecify.txt
new file mode 100644
index 0000000000..3ed6e31751
--- /dev/null
+++ b/seatunnel-dist/release-docs/licenses/LICENSE-jspecify.txt
@@ -0,0 +1 @@
+License: {Name: The Apache License, Version 2.0, URL: http://www.apache.org/licenses/LICENSE-2.0.txt, Distribution: repo, Comments: , }
diff --git a/seatunnel-e2e/seatunnel-connector-v2-e2e/connector-nats-jetstream-e2e/pom.xml b/seatunnel-e2e/seatunnel-connector-v2-e2e/connector-nats-jetstream-e2e/pom.xml
new file mode 100644
index 0000000000..b396a97ab3
--- /dev/null
+++ b/seatunnel-e2e/seatunnel-connector-v2-e2e/connector-nats-jetstream-e2e/pom.xml
@@ -0,0 +1,67 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+    Licensed to the Apache Software Foundation (ASF) under one or more
+    contributor license agreements.  See the NOTICE file distributed with
+    this work for additional information regarding copyright ownership.
+    The ASF licenses this file to You under the Apache License, Version 2.0
+    (the "License"); you may not use this file except in compliance with
+    the License.  You may obtain a copy of the License at
+       http://www.apache.org/licenses/LICENSE-2.0
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>org.apache.seatunnel</groupId>
+        <artifactId>seatunnel-connector-v2-e2e</artifactId>
+        <version>${revision}</version>
+    </parent>
+
+    <artifactId>connector-nats-jetstream-e2e</artifactId>
+    <name>SeaTunnel : E2E : Connector V2 : NATS JetStream</name>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.apache.seatunnel</groupId>
+            <artifactId>seatunnel-starter</artifactId>
+            <version>${project.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.seatunnel</groupId>
+            <artifactId>seatunnel-jackson</artifactId>
+            <version>${project.version}</version>
+            <classifier>optional</classifier>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.seatunnel</groupId>
+            <artifactId>connector-nats-jetstream</artifactId>
+            <version>${project.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.seatunnel</groupId>
+            <artifactId>connector-fake</artifactId>
+            <version>${project.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.seatunnel</groupId>
+            <artifactId>connector-console</artifactId>
+            <version>${project.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.seatunnel</groupId>
+            <artifactId>connector-assert</artifactId>
+            <version>${project.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+</project>
diff --git a/seatunnel-e2e/seatunnel-connector-v2-e2e/connector-nats-jetstream-e2e/src/test/java/org/apache/seatunnel/e2e/connector/natsjetstream/NatsJetStreamIT.java b/seatunnel-e2e/seatunnel-connector-v2-e2e/connector-nats-jetstream-e2e/src/test/java/org/apache/seatunnel/e2e/connector/natsjetstream/NatsJetStreamIT.java
new file mode 100644
index 0000000000..c253ab4a60
--- /dev/null
+++ b/seatunnel-e2e/seatunnel-connector-v2-e2e/connector-nats-jetstream-e2e/src/test/java/org/apache/seatunnel/e2e/connector/natsjetstream/NatsJetStreamIT.java
@@ -0,0 +1,402 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.seatunnel.e2e.connector.natsjetstream;
+
+import org.apache.seatunnel.e2e.common.TestResource;
+import org.apache.seatunnel.e2e.common.TestSuiteBase;
+import org.apache.seatunnel.e2e.common.container.TestContainer;
+
+import org.awaitility.Awaitility;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.TestTemplate;
+import org.testcontainers.containers.Container;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.output.Slf4jLogConsumer;
+import org.testcontainers.containers.wait.strategy.HostPortWaitStrategy;
+import org.testcontainers.lifecycle.Startables;
+import org.testcontainers.utility.DockerImageName;
+import org.testcontainers.utility.DockerLoggerFactory;
+
+import io.nats.client.Connection;
+import io.nats.client.JetStreamApiException;
+import io.nats.client.JetStreamManagement;
+import io.nats.client.JetStreamSubscription;
+import io.nats.client.Message;
+import io.nats.client.Nats;
+import io.nats.client.Options;
+import io.nats.client.PullSubscribeOptions;
+import io.nats.client.api.RetentionPolicy;
+import io.nats.client.api.StorageType;
+import io.nats.client.api.StreamConfiguration;
+import io.nats.client.impl.Headers;
+import lombok.extern.slf4j.Slf4j;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.time.Duration;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+@Slf4j
+public class NatsJetStreamIT extends TestSuiteBase implements TestResource {
+
+    private static final String IMAGE = "nats:2.10.14-alpine";
+    private static final String NATS_HOST = "nats-jetstream-e2e";
+    private static final int NATS_PORT = 4222;
+    private static final Duration STARTUP_TIMEOUT = Duration.ofMinutes(2);
+    private static final Duration TEST_TIMEOUT = Duration.ofSeconds(30);
+
+    private static final String JSON_STREAM = "json_stream";
+    private static final String JSON_SUBJECT = "orders.json";
+    private static final String NATIVE_STREAM = "native_stream";
+    private static final String NATIVE_SUBJECT_ONE = "events.native.alpha";
+    private static final String NATIVE_SUBJECT_TWO = "events.native.beta";
+    private static final String DEFAULT_STREAM = "default_stream";
+    private static final String DEFAULT_SUBJECT = "events.default";
+
+    private static final List<String> EXPECTED_JSON_PAYLOADS =
+            Arrays.asList(
+                    "{\"id\":101,\"name\":\"alice\",\"score\":9.5}",
+                    "{\"id\":102,\"name\":\"bob\",\"score\":7.25}",
+                    "{\"id\":103,\"name\":\"carol\",\"score\":8.75}");
+
+    private static final List<NativeExpectedMessage> EXPECTED_NATIVE_MESSAGES =
+            Arrays.asList(
+                    new NativeExpectedMessage(
+                            NATIVE_SUBJECT_ONE,
+                            "msg-1",
+                            mapOf("tenant", "acme", "trace", "trace-1"),
+                            "payload-1".getBytes(StandardCharsets.UTF_8)),
+                    new NativeExpectedMessage(
+                            NATIVE_SUBJECT_TWO,
+                            "msg-2",
+                            mapOf("tenant", "beta", "trace", "trace-2"),
+                            "payload-2".getBytes(StandardCharsets.UTF_8)),
+                    new NativeExpectedMessage(
+                            NATIVE_SUBJECT_ONE,
+                            "msg-3",
+                            mapOf("tenant", "acme", "trace", "trace-3"),
+                            "payload-3".getBytes(StandardCharsets.UTF_8)));
+
+    private static final List<String> EXPECTED_DEFAULT_PAYLOADS =
+            Arrays.asList(
+                    "{\"id\":201,\"status\":\"queued\",\"enabled\":true}",
+                    "{\"id\":202,\"status\":\"done\",\"enabled\":false}");
+
+    private GenericContainer<?> natsContainer;
+    private Connection adminConnection;
+
+    @BeforeAll
+    @Override
+    public void startUp() throws Exception {
+        natsContainer =
+                new GenericContainer<>(DockerImageName.parse(IMAGE))
+                        .withCommand("--jetstream")
+                        .withNetwork(NETWORK)
+                        .withNetworkAliases(NATS_HOST)
+                        .withExposedPorts(NATS_PORT)
+                        .withLogConsumer(new Slf4jLogConsumer(DockerLoggerFactory.getLogger(IMAGE)))
+                        .waitingFor(new HostPortWaitStrategy().withStartupTimeout(STARTUP_TIMEOUT));
+        Startables.deepStart(Stream.of(natsContainer)).join();
+        adminConnection = createClientConnection();
+    }
+
+    @AfterAll
+    @Override
+    public void tearDown() throws Exception {
+        if (adminConnection != null) {
+            adminConnection.close();
+            adminConnection = null;
+        }
+        if (natsContainer != null) {
+            natsContainer.close();
+            natsContainer = null;
+        }
+    }
+
+    @TestTemplate
+    public void testJsonSink(TestContainer container) throws Exception {
+        recreateStream(JSON_STREAM, JSON_SUBJECT);
+        try (VerificationConsumer consumer =
+                createVerificationConsumer(JSON_STREAM, JSON_SUBJECT)) {
+            Container.ExecResult execResult =
+                    container.executeJob("/fake_to_nats_jetstream_json.conf");
+            Assertions.assertEquals(0, execResult.getExitCode(), execResult.getStderr());
+
+            List<Message> messages = consumer.awaitMessages(EXPECTED_JSON_PAYLOADS.size());
+            List<String> actualPayloads =
+                    messages.stream()
+                            .map(message -> new String(message.getData(), StandardCharsets.UTF_8))
+                            .collect(Collectors.toList());
+            Assertions.assertEquals(EXPECTED_JSON_PAYLOADS, actualPayloads);
+            Assertions.assertTrue(
+                    messages.stream()
+                            .allMatch(message -> JSON_SUBJECT.equals(message.getSubject())));
+        }
+    }
+
+    @TestTemplate
+    public void testNativeSink(TestContainer container) throws Exception {
+        recreateStream(NATIVE_STREAM, NATIVE_SUBJECT_ONE, NATIVE_SUBJECT_TWO);
+        try (VerificationConsumer consumer =
+                createVerificationConsumer(NATIVE_STREAM, "events.native.*")) {
+            Container.ExecResult execResult =
+                    container.executeJob("/fake_to_nats_jetstream_native.conf");
+            Assertions.assertEquals(0, execResult.getExitCode(), execResult.getStderr());
+
+            List<Message> messages = consumer.awaitMessages(EXPECTED_NATIVE_MESSAGES.size());
+            List<NativeActualMessage> actualMessages =
+                    messages.stream()
+                            .map(NativeActualMessage::fromMessage)
+                            .collect(Collectors.toList());
+            List<NativeActualMessage> expectedMessages =
+                    EXPECTED_NATIVE_MESSAGES.stream()
+                            .map(NativeExpectedMessage::toActualMessage)
+                            .sorted(NativeActualMessage::compareByContent)
+                            .collect(Collectors.toList());
+            actualMessages.sort(NativeActualMessage::compareByContent);
+            Assertions.assertEquals(expectedMessages, actualMessages);
+        }
+    }
+
+    @TestTemplate
+    public void testNativeSinkWithDefaultFieldMapping(TestContainer container) throws Exception {
+        recreateStream(DEFAULT_STREAM, DEFAULT_SUBJECT);
+        try (VerificationConsumer consumer =
+                createVerificationConsumer(DEFAULT_STREAM, DEFAULT_SUBJECT)) {
+            Container.ExecResult execResult =
+                    container.executeJob("/fake_to_nats_jetstream_native_defaults.conf");
+            Assertions.assertEquals(0, execResult.getExitCode(), execResult.getStderr());
+
+            List<Message> messages = consumer.awaitMessages(EXPECTED_DEFAULT_PAYLOADS.size());
+            List<String> actualPayloads =
+                    messages.stream()
+                            .map(message -> new String(message.getData(), StandardCharsets.UTF_8))
+                            .collect(Collectors.toList());
+            Assertions.assertEquals(EXPECTED_DEFAULT_PAYLOADS, actualPayloads);
+            Assertions.assertTrue(
+                    messages.stream()
+                            .allMatch(message -> DEFAULT_SUBJECT.equals(message.getSubject())));
+            Assertions.assertTrue(
+                    messages.stream()
+                            .allMatch(
+                                    message -> {
+                                        Headers headers = message.getHeaders();
+                                        return headers == null || headers.isEmpty();
+                                    }));
+        }
+    }
+
+    private Connection createClientConnection() throws IOException, InterruptedException {
+        Options options =
+                new Options.Builder()
+                        .server(getMappedNatsUrl())
+                        .connectionTimeout(Duration.ofSeconds(30))
+                        .build();
+        return Nats.connect(options);
+    }
+
+    private String getMappedNatsUrl() {
+        return "nats://" + natsContainer.getHost() + ":" + natsContainer.getMappedPort(NATS_PORT);
+    }
+
+    private void recreateStream(String streamName, String... subjects)
+            throws IOException, JetStreamApiException {
+        JetStreamManagement management = adminConnection.jetStreamManagement();
+        try {
+            management.deleteStream(streamName);
+        } catch (JetStreamApiException e) {
+            if (e.getErrorCode() != 404) {
+                throw e;
+            }
+        }
+        management.addStream(
+                StreamConfiguration.builder()
+                        .name(streamName)
+                        .storageType(StorageType.Memory)
+                        .retentionPolicy(RetentionPolicy.Limits)
+                        .subjects(subjects)
+                        .build());
+    }
+
+    private VerificationConsumer createVerificationConsumer(
+            String streamName, String subscriptionSubject)
+            throws IOException, InterruptedException, JetStreamApiException {
+        Connection connection = createClientConnection();
+        PullSubscribeOptions subscribeOptions =
+                PullSubscribeOptions.builder().stream(streamName)
+                        .durable("consumer-" + UUID.randomUUID())
+                        .build();
+        JetStreamSubscription subscription =
+                connection.jetStream().subscribe(subscriptionSubject, subscribeOptions);
+        return new VerificationConsumer(connection, subscription);
+    }
+
+    private static Map<String, String> mapOf(String... keyValues) {
+        Map<String, String> map = new LinkedHashMap<>();
+        for (int i = 0; i < keyValues.length; i += 2) {
+            map.put(keyValues[i], keyValues[i + 1]);
+        }
+        return map;
+    }
+
+    private static final class VerificationConsumer implements AutoCloseable {
+        private final Connection connection;
+        private final JetStreamSubscription subscription;
+
+        private VerificationConsumer(Connection connection, JetStreamSubscription subscription) {
+            this.connection = connection;
+            this.subscription = subscription;
+        }
+
+        private List<Message> awaitMessages(int expectedCount) {
+            List<Message> receivedMessages = new ArrayList<>(expectedCount);
+            Awaitility.await()
+                    .atMost(TEST_TIMEOUT)
+                    .pollInterval(200, TimeUnit.MILLISECONDS)
+                    .until(
+                            () -> {
+                                subscription.pull(expectedCount - receivedMessages.size());
+                                while (receivedMessages.size() < expectedCount) {
+                                    Message message =
+                                            subscription.nextMessage(Duration.ofMillis(200));
+                                    if (message == null) {
+                                        break;
+                                    }
+                                    receivedMessages.add(message);
+                                    message.ack();
+                                }
+                                return receivedMessages.size() >= expectedCount;
+                            });
+            return receivedMessages;
+        }
+
+        @Override
+        public void close() throws Exception {
+            if (connection != null) {
+                connection.close();
+            }
+        }
+    }
+
+    private static final class NativeExpectedMessage {
+        private final String subject;
+        private final String messageId;
+        private final Map<String, String> headers;
+        private final byte[] payload;
+
+        private NativeExpectedMessage(
+                String subject, String messageId, Map<String, String> headers, byte[] payload) {
+            this.subject = subject;
+            this.messageId = messageId;
+            this.headers = headers;
+            this.payload = payload;
+        }
+
+        private NativeActualMessage toActualMessage() {
+            return new NativeActualMessage(subject, messageId, headers, payload);
+        }
+    }
+
+    private static final class NativeActualMessage {
+        private final String subject;
+        private final String messageId;
+        private final Map<String, String> headers;
+        private final byte[] payload;
+
+        private NativeActualMessage(
+                String subject, String messageId, Map<String, String> headers, byte[] payload) {
+            this.subject = subject;
+            this.messageId = messageId;
+            this.headers = headers;
+            this.payload = payload;
+        }
+
+        private static NativeActualMessage fromMessage(Message message) {
+            Headers headers = message.getHeaders();
+            Map<String, String> headerMap = new LinkedHashMap<>();
+            String messageId = null;
+            if (headers != null) {
+                for (String key : headers.keySet()) {
+                    if (!"Nats-Msg-Id".equals(key)) {
+                        headerMap.put(key, headers.getFirst(key));
+                    }
+                }
+                messageId = headers.getFirst("Nats-Msg-Id");
+            }
+            return new NativeActualMessage(
+                    message.getSubject(), messageId, headerMap, message.getData());
+        }
+
+        private static int compareByContent(NativeActualMessage left, NativeActualMessage right) {
+            int subjectComparison = left.subject.compareTo(right.subject);
+            if (subjectComparison != 0) {
+                return subjectComparison;
+            }
+            int messageIdComparison =
+                    java.util.Objects.toString(left.messageId, "")
+                            .compareTo(java.util.Objects.toString(right.messageId, ""));
+            if (messageIdComparison != 0) {
+                return messageIdComparison;
+            }
+            return comparePayloads(left.payload, right.payload);
+        }
+
+        private static int comparePayloads(byte[] left, byte[] right) {
+            int length = Math.min(left.length, right.length);
+            for (int i = 0; i < length; i++) {
+                int comparison = Byte.compare(left[i], right[i]);
+                if (comparison != 0) {
+                    return comparison;
+                }
+            }
+            return Integer.compare(left.length, right.length);
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+            if (this == obj) {
+                return true;
+            }
+            if (!(obj instanceof NativeActualMessage)) {
+                return false;
+            }
+            NativeActualMessage that = (NativeActualMessage) obj;
+            return subject.equals(that.subject)
+                    && java.util.Objects.equals(messageId, that.messageId)
+                    && headers.equals(that.headers)
+                    && Arrays.equals(payload, that.payload);
+        }
+
+        @Override
+        public int hashCode() {
+            int result = java.util.Objects.hash(subject, messageId, headers);
+            result = 31 * result + Arrays.hashCode(payload);
+            return result;
+        }
+    }
+}
diff --git a/seatunnel-e2e/seatunnel-connector-v2-e2e/connector-nats-jetstream-e2e/src/test/resources/fake_to_nats_jetstream_json.conf b/seatunnel-e2e/seatunnel-connector-v2-e2e/connector-nats-jetstream-e2e/src/test/resources/fake_to_nats_jetstream_json.conf
new file mode 100644
index 0000000000..0018e56a7b
--- /dev/null
+++ b/seatunnel-e2e/seatunnel-connector-v2-e2e/connector-nats-jetstream-e2e/src/test/resources/fake_to_nats_jetstream_json.conf
@@ -0,0 +1,70 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+env {
+  parallelism = 1
+  job.mode = "BATCH"
+  job.name = "SeaTunnel_NatsJetStream_Json_E2E"
+}
+
+source {
+  FakeSource {
+    rows = [
+      {
+        kind = INSERT
+        fields = {
+          id = 101
+          name = "alice"
+          score = 9.5
+        }
+      },
+      {
+        kind = INSERT
+        fields = {
+          id = 102
+          name = "bob"
+          score = 7.25
+        }
+      },
+      {
+        kind = INSERT
+        fields = {
+          id = 103
+          name = "carol"
+          score = 8.75
+        }
+      }
+    ]
+    schema = {
+      fields {
+        id = int
+        name = string
+        score = double
+      }
+    }
+    plugin_output = "json_fake"
+  }
+}
+
+sink {
+  NatsJetStream {
+    plugin_input = "json_fake"
+    url = "nats://nats-jetstream-e2e:4222"
+    subject = "orders.json"
+    format = "json"
+  }
+}
diff --git a/seatunnel-e2e/seatunnel-connector-v2-e2e/connector-nats-jetstream-e2e/src/test/resources/fake_to_nats_jetstream_native.conf b/seatunnel-e2e/seatunnel-connector-v2-e2e/connector-nats-jetstream-e2e/src/test/resources/fake_to_nats_jetstream_native.conf
new file mode 100644
index 0000000000..75115eb115
--- /dev/null
+++ b/seatunnel-e2e/seatunnel-connector-v2-e2e/connector-nats-jetstream-e2e/src/test/resources/fake_to_nats_jetstream_native.conf
@@ -0,0 +1,90 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+env {
+  parallelism = 1
+  job.mode = "BATCH"
+  job.name = "SeaTunnel_NatsJetStream_Native_E2E"
+}
+
+source {
+  FakeSource {
+    rows = [
+      {
+        kind = INSERT
+        fields = {
+          dynamic_subject = "events.native.alpha"
+          message_id = "msg-1"
+          attributes = {
+            tenant = "acme"
+            trace = "trace-1"
+          }
+          payload = "cGF5bG9hZC0x"
+        }
+      },
+      {
+        kind = INSERT
+        fields = {
+          dynamic_subject = "events.native.beta"
+          message_id = "msg-2"
+          attributes = {
+            tenant = "beta"
+            trace = "trace-2"
+          }
+          payload = "cGF5bG9hZC0y"
+        }
+      },
+      {
+        kind = INSERT
+        fields = {
+          dynamic_subject = "events.native.alpha"
+          message_id = "msg-3"
+          attributes = {
+            tenant = "acme"
+            trace = "trace-3"
+          }
+          payload = "cGF5bG9hZC0z"
+        }
+      }
+    ]
+    schema = {
+      fields {
+        dynamic_subject = string
+        message_id = string
+        attributes = "map<string,string>"
+        payload = bytes
+      }
+    }
+    plugin_output = "native_fake"
+  }
+}
+
+sink {
+  NatsJetStream {
+    plugin_input = "native_fake"
+    url = "nats://nats-jetstream-e2e:4222"
+    subject = "events.native.default"
+     format = "native"
+     include_row_kind_header = false
+     native_format_fields = {
+      subject = dynamic_subject
+      id = message_id
+      headers = attributes
+      data = payload
+    }
+  }
+}
diff --git a/seatunnel-e2e/seatunnel-connector-v2-e2e/connector-nats-jetstream-e2e/src/test/resources/fake_to_nats_jetstream_native_defaults.conf b/seatunnel-e2e/seatunnel-connector-v2-e2e/connector-nats-jetstream-e2e/src/test/resources/fake_to_nats_jetstream_native_defaults.conf
new file mode 100644
index 0000000000..b94dfdeda2
--- /dev/null
+++ b/seatunnel-e2e/seatunnel-connector-v2-e2e/connector-nats-jetstream-e2e/src/test/resources/fake_to_nats_jetstream_native_defaults.conf
@@ -0,0 +1,66 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+env {
+  parallelism = 1
+  job.mode = "BATCH"
+  job.name = "SeaTunnel_NatsJetStream_Native_Defaults_E2E"
+}
+
+source {
+  FakeSource {
+    rows = [
+      {
+        kind = INSERT
+        fields = {
+          subject = null
+          id = null
+          headers = null
+          data = "eyJpZCI6MjAxLCJzdGF0dXMiOiJxdWV1ZWQiLCJlbmFibGVkIjp0cnVlfQ=="
+        }
+      },
+      {
+        kind = INSERT
+        fields = {
+          subject = "   "
+          id = ""
+          headers = null
+          data = "eyJpZCI6MjAyLCJzdGF0dXMiOiJkb25lIiwiZW5hYmxlZCI6ZmFsc2V9"
+        }
+      }
+    ]
+    schema = {
+      fields {
+        subject = string
+        id = string
+        headers = "map<string,string>"
+        data = bytes
+      }
+    }
+    plugin_output = "default_native_fake"
+  }
+}
+
+sink {
+  NatsJetStream {
+    plugin_input = "default_native_fake"
+    url = "nats://nats-jetstream-e2e:4222"
+    subject = "events.default"
+     format = "native"
+     include_row_kind_header = false
+   }
+}
diff --git a/seatunnel-e2e/seatunnel-connector-v2-e2e/pom.xml b/seatunnel-e2e/seatunnel-connector-v2-e2e/pom.xml
index c86be9218d..a60755b9d2 100644
--- a/seatunnel-e2e/seatunnel-connector-v2-e2e/pom.xml
+++ b/seatunnel-e2e/seatunnel-connector-v2-e2e/pom.xml
@@ -96,6 +96,7 @@
         <module>connector-fluss-e2e</module>
         <module>connector-lance-e2e</module>
         <module>connector-bigquery-e2e</module>
+        <module>connector-nats-jetstream-e2e</module>
     </modules>
 
     <properties>