diff --git a/docs-en/04-develop/01-connect/_category_.yml b/docs-en/04-develop/01-connect/_category_.yml
index f75d563ac9e061f8b8d66392031413f4051e351e..83f9754f582f541ca62c7ff8701698dd949c3f99 100644
--- a/docs-en/04-develop/01-connect/_category_.yml
+++ b/docs-en/04-develop/01-connect/_category_.yml
@@ -1 +1 @@
-label: 建立连接
+label: Connect
diff --git a/docs-en/04-develop/01-connect/_connect_c.mdx b/docs-en/04-develop/01-connect/_connect_c.mdx
index 9cd8669561195b49e8428ed490ad97bb5653ae6a..174bf45c4e2f26bab8f57c098f9f8f00d2f5064d 100644
--- a/docs-en/04-develop/01-connect/_connect_c.mdx
+++ b/docs-en/04-develop/01-connect/_connect_c.mdx
@@ -1,3 +1,3 @@
-```c title="原生连接"
+```c title="Native Connection"
 {{#include docs-examples/c/connect_example.c}}
 ```
diff --git a/docs-en/04-develop/01-connect/_connect_cs.mdx b/docs-en/04-develop/01-connect/_connect_cs.mdx
index 204173dd329f6f214a9ea44c2f360be2cdbfdab8..43fb50cac9cfebdcb363e75aca020c0e70f36420 100644
--- a/docs-en/04-develop/01-connect/_connect_cs.mdx
+++ b/docs-en/04-develop/01-connect/_connect_cs.mdx
@@ -1,7 +1,7 @@
-```csharp title="原生连接"
+```csharp title="Native Connection"
 {{#include docs-examples/csharp/ConnectExample.cs}}
 ```
 :::info
-C# 连接器目前只支持原生连接。
+C# connector supports only native connection for now.
 
 :::
\ No newline at end of file
diff --git a/docs-en/04-develop/01-connect/_connect_go.mdx b/docs-en/04-develop/01-connect/_connect_go.mdx
index 4e4f189672f2fda4b807fe628d4455a41ac4cb69..314e68314717e80da8af4fa802f8cf478185d307 100644
--- a/docs-en/04-develop/01-connect/_connect_go.mdx
+++ b/docs-en/04-develop/01-connect/_connect_go.mdx
@@ -1,14 +1,14 @@
-#### 使用数据库访问统一接口
-```go title="原生连接"
+#### Unified Database Access Interface
+```go title="Native Connection"
 {{#include docs-examples/go/connect/cgoexample/main.go}}
 ```
-```go title="REST 连接"
+```go title="REST Connection"
 {{#include docs-examples/go/connect/restexample/main.go}}
 ```
-#### 使用高级封装
-也可以使用 driver-go 的 af 包建立连接。这个模块封装了 TDengine 的高级功能, 如：参数绑定、订阅等。
+#### Advanced Features
+The af package of driver-go can also be used to establish connection, with this way some advanced features of TDengine, like parameter binding and subscription, can be used.
 
-```go title="使用 af 包建立原生连接"
+```go title="Establish native connection using af package"
 {{#include docs-examples/go/connect/afconn/main.go}}
 ```
 
diff --git a/docs-en/04-develop/01-connect/_connect_java.mdx b/docs-en/04-develop/01-connect/_connect_java.mdx
index cd6d7c4cab9a84abb22895c704debd260884081f..f0544ed6f4d2a7c2a34174910f22f3a5cbbe9ebd 100644
--- a/docs-en/04-develop/01-connect/_connect_java.mdx
+++ b/docs-en/04-develop/01-connect/_connect_java.mdx
@@ -1,11 +1,12 @@
-```java title="原生连接"
+```java title="Native Connection"
 {{#include docs-examples/java/src/main/java/com/taos/example/JNIConnectExample.java}}
 ```
-```java title="REST 连接"
+```java title="REST Connection"
 {{#include docs-examples/java/src/main/java/com/taos/example/RESTConnectExample.java:main}}
 ```
-使用REST 连接时，如果查询数据量比较大，还可开启批量拉取功能。
-```java title="开启批量拉取功能" {4}
+When using REST connection, the feature of bulk pulling can be enabled if the size of resulting data set is huge.
+
+```java title="Enable Bulk Pulling" {4}
 {{#include docs-examples/java/src/main/java/com/taos/example/WSConnectExample.java:main}}
 ```
-更多连接参数配置，参考[Java 连接器](/reference/connector/java)
\ No newline at end of file
+More configuration about connection，please refer to [Java Connector](/reference/connector/java)
\ No newline at end of file
diff --git a/docs-en/04-develop/01-connect/_connect_node.mdx b/docs-en/04-develop/01-connect/_connect_node.mdx
index 8a259888f87d4d441c58b9a8a9008b19273c1a58..9c0e5b0be1dc7f289832fba9bb1c6cae9ad4694f 100644
--- a/docs-en/04-develop/01-connect/_connect_node.mdx
+++ b/docs-en/04-develop/01-connect/_connect_node.mdx
@@ -1,6 +1,6 @@
-```js title="原生连接"
+```js title="Native Connection"
 {{#include docs-examples/node/nativeexample/connect.js}}
 ```
-```js title="REST 连接"
+```js title="REST Connection"
 {{#include docs-examples/node/restexample/connect.js}}
 ```
\ No newline at end of file
diff --git a/docs-en/04-develop/01-connect/_connect_python.mdx b/docs-en/04-develop/01-connect/_connect_python.mdx
index 331ec0f693601baeb28ede7b0278e67f1471c187..02354057726a45cee816128e64dcc23f1189aa3c 100644
--- a/docs-en/04-develop/01-connect/_connect_python.mdx
+++ b/docs-en/04-develop/01-connect/_connect_python.mdx
@@ -1,3 +1,3 @@
-```python title="原生连接"
+```python title="Native Connection"
 {{#include docs-examples/python/connect_exmaple.py}}
 ```
\ No newline at end of file
diff --git a/docs-en/04-develop/01-connect/_connect_r.mdx b/docs-en/04-develop/01-connect/_connect_r.mdx
index a69a57f66be3672d61cb0f84f43aba123cfbd5aa..0f6e6cc18e37591d221df011b676994ef7c9b568 100644
--- a/docs-en/04-develop/01-connect/_connect_r.mdx
+++ b/docs-en/04-develop/01-connect/_connect_r.mdx
@@ -1,3 +1,3 @@
-```r title="原生连接"
+```r title="Native Connection"
 {{#include docs-examples/R/connect_native.r:demo}}
 ```
\ No newline at end of file
diff --git a/docs-en/04-develop/01-connect/_connect_rust.mdx b/docs-en/04-develop/01-connect/_connect_rust.mdx
index b051108452d16f207ce10b128f5de2e5f507200f..0165114d2aec7cb080a762a92ee2158852897b63 100644
--- a/docs-en/04-develop/01-connect/_connect_rust.mdx
+++ b/docs-en/04-develop/01-connect/_connect_rust.mdx
@@ -1,7 +1,7 @@
-```rust title="原生连接/REST 连接"
+```rust title="Native Connection/REST Connection"
 {{#include docs-examples/rust/nativeexample/examples/connect.rs}}
 ```
 :::note
-对于 Rust 连接器， 连接方式的不同只体现在使用的特性不同。如果启用了 "rest" 特性，那么只有 RESTful 的实现会被编译进来。
+For Rust connector, the connection depends on the feature being used. If "rest" feature is enabled, then only the implementation for "rest" is compiled and packaged.
 
 :::
diff --git a/docs-en/04-develop/01-connect/index.md b/docs-en/04-develop/01-connect/index.md
index 07bcc8ea125a0e4bc8f40a1bd2fab3a568b3402d..3a6f0ea7d7335463a67f49acbcdc4d33046cba60 100644
--- a/docs-en/04-develop/01-connect/index.md
+++ b/docs-en/04-develop/01-connect/index.md
@@ -1,44 +1,45 @@
 ---
-title: 建立连接
-description: "本节介绍如何使用连接器建立与 TDengine 的连接，给出连接器安装、连接的简单说明。"
+sidebar_label: Connect
+title: Connect to TDengine
+description: "This document explains how to establish connection to TDengine, and briefly introduce how to install and use TDengine connectors."
 ---
 
 import Tabs from "@theme/Tabs";
 import TabItem from "@theme/TabItem";
-import ConnJava from "./_connect_java.mdx";
-import ConnGo from "./_connect_go.mdx";
-import ConnRust from "./_connect_rust.mdx";
-import ConnNode from "./_connect_node.mdx";
-import ConnPythonNative from "./_connect_python.mdx";
-import ConnCSNative from "./_connect_cs.mdx";
-import ConnC from "./_connect_c.mdx";
-import ConnR from "./_connect_r.mdx";
-import InstallOnWindows from "../../14-reference/03-connector/_linux_install.mdx";
-import InstallOnLinux from "../../14-reference/03-connector/_windows_install.mdx";
-import VerifyLinux from "../../14-reference/03-connector/_verify_linux.mdx";
-import VerifyWindows from "../../14-reference/03-connector/_verify_windows.mdx";
+import ConnJava from "./\_connect_java.mdx";
+import ConnGo from "./\_connect_go.mdx";
+import ConnRust from "./\_connect_rust.mdx";
+import ConnNode from "./\_connect_node.mdx";
+import ConnPythonNative from "./\_connect_python.mdx";
+import ConnCSNative from "./\_connect_cs.mdx";
+import ConnC from "./\_connect_c.mdx";
+import ConnR from "./\_connect_r.mdx";
+import InstallOnWindows from "../../14-reference/03-connector/\_linux_install.mdx";
+import InstallOnLinux from "../../14-reference/03-connector/\_windows_install.mdx";
+import VerifyLinux from "../../14-reference/03-connector/\_verify_linux.mdx";
+import VerifyWindows from "../../14-reference/03-connector/\_verify_windows.mdx";
 
-TDengine 提供 REST API，容许在任何平台的任何应用程序通过它访问 TDengine 运行实例，详细介绍请看 [REST API](/reference/rest-api/)。除 REST API 之外，TDengine 还提供多种编程语言的连接器方便用户开发应用程序，其中包括 C/C++、Java、Python、Go、Node.js、C# 等。 本节介绍如何使用连接器建立与 TDengine 的连接，给出连接器安装、连接的简单说明。关于各连接器的详细功能说明，请查看[连接器](https://docs.taosdata.com/reference/connector/)
+Any application programs running on any kind of platforms can access TDengine through the REST API provided by TDengine. For the details please refer to [REST API](/reference/rest-api/). Besides, application programs can use the connectors of multiple languages to access TDengine, including C/C++, Java, Python, Go, Node.js, C#, and Rust. This chapter describes how to establish connection to TDengine and briefly introduce how to install and use connectors. For details about the connectors please refer to [Connectors](https://docs.taosdata.com/reference/connector/)
 
-## 连接器建立连接的方式
+## Establish Connection
 
-连接器建立连接的方式，TDengine 提供两种:
+There are two ways to establish connections to TDengine:
 
-1. 通过 taosAdapter 组件提供的 REST API 建立与 taosd 的连接，这种连接方式下文中简称"REST 连接“
-2. 通过客户端驱动程序 taosc 直接与服务端程序 taosd 建立连接，这种连接方式下文中简称“原生连接”。
+1. Connection to taosd can be established through the REST API provided by taosAdapter component, this way is called "REST connection" hereinafter.
+2. Connection to taosd can be established through the client side driver taosc, this way is called "Native connection" hereinafter.
 
-无论使用何种方式建立连接，连接器都提供了相同或相似的 API 操作数据库，都可以执行 SQL 语句，只是初始化连接的方式稍有不同，用户在使用上不会感到什么差别。
+Either way, same or similar APIs are provided by connectors to access database or execute SQL statements, no obvious difference can be observed.
 
-关键不同点在于：
+Key differences：
 
-1. 使用 REST 连接，用户无需安装客户端驱动程序 taosc，具有跨平台易用的优势，但性能要下降 30%左右。
-2. 使用原生连接可以体验 TDengine 的全部功能，如[参数绑定接口](/reference/connector/cpp#参数绑定-api)、[订阅](reference/connector/cpp#数据订阅接口)等等。
+1. With REST connection, it's not necessary to install the client side driver taosc, it's more friendly for cross-platform with the cost of 30% performance downgrade.
+2. With native connection, full compatibility of TDengine can be utilized, like [Parameter Binding](/reference/connector/cpp#Parameter Binding-api), [Subscription](reference/connector/cpp#Subscription), etc.
 
-## 安装客户端驱动 taosc
+## Install Client Driver taosc
 
 如果选择原生连接，而且应用程序不在 TDengine 同一台服务器上运行，你需要先安装客户端驱动，否则可以跳过此一步。为避免客户端驱动和服务端不兼容，请使用一致的版本。
 
-### 安装步骤
+### Install
 
 <Tabs defaultValue="linux" groupId="os">
   <TabItem value="linux" label="Linux">
@@ -49,9 +50,9 @@ TDengine 提供 REST API，容许在任何平台的任何应用程序通过它
   </TabItem>
 </Tabs>
 
-### 安装验证
+### Verify
 
-以上安装和配置完成后，并确认 TDengine 服务已经正常启动运行，此时可以执行安装包里带有的 TDengine 命令行程序 taos 进行登录。
+After the above installation and configuration are done and making sure TDengine service is already started and in service, the Shell command `taos` can be launched to access TDengine.以
 
 <Tabs defaultValue="linux" groupId="os">
   <TabItem value="linux" label="Linux">
@@ -62,12 +63,12 @@ TDengine 提供 REST API，容许在任何平台的任何应用程序通过它
   </TabItem>
 </Tabs>
 
-## 安装连接器
+## Install Connectors
 
 <Tabs groupId="lang">
 <TabItem label="Java" value="java">
   
-如果使用 maven 管理项目，只需在 pom.xml 中加入以下依赖。
+If `maven` is used to manage the projects, what needs to be done is only adding below dependency in `pom.xml`.
 
 ```xml
 <dependency>
@@ -80,13 +81,13 @@ TDengine 提供 REST API，容许在任何平台的任何应用程序通过它
 </TabItem>
 <TabItem label="Python" value="python">
 
-使用 `pip` 从 PyPI 安装:
+Install from PyPI using `pip`:
 
 ```
 pip install taospy
 ```
 
-从 Git URL 安装：
+Install from Git URL:
 
 ```
 pip install git+https://github.com/taosdata/taos-connector-python.git
@@ -95,7 +96,7 @@ pip install git+https://github.com/taosdata/taos-connector-python.git
 </TabItem>
 <TabItem label="Go" value="go">
 
-编辑 `go.mod` 添加 `driver-go` 依赖即可。
+Just need to add `driver-go` dependency in `go.mod` .
 
 ```go-mod title=go.mod
 module goexample
@@ -106,14 +107,14 @@ require github.com/taosdata/driver-go/v2 develop
 ```
 
 :::note
-driver-go 使用 cgo 封装了 taosc 的 API。cgo 需要使用 gcc 编译 C 的源码。因此需要确保你的系统上有 gcc。
+`driver-go` uses `cgo` to wrap the APIs provided by taosc, while `cgo` needs `gcc` to compile source code in C language, so please make sure you have proper `gcc` on your system.
 
 :::
 
 </TabItem>
 <TabItem label="Rust" value="rust">
 
-编辑 `Cargo.toml` 添加 `libtaos` 依赖即可。
+Just need to add `libtaos` dependency in `Cargo.toml`.
 
 ```toml title=Cargo.toml
 [dependencies]
@@ -121,7 +122,7 @@ libtaos = { version = "0.4.2"}
 ```
 
 :::info
-Rust 连接器通过不同的特性区分不同的连接方式。如果要建立 REST 连接，需要开启 `rest` 特性：
+Rust connector uses different features to distinguish the way to establish connection. To establish REST connection, please enable `rest` feature.
 
 ```toml
 libtaos = { version = "*", features = ["rest"] }
@@ -132,28 +133,28 @@ libtaos = { version = "*", features = ["rest"] }
 </TabItem>
 <TabItem label="Node.js" value="node">
 
-Node.js 连接器通过不同的包提供不同的连接方式。
+Node.js connector provides different ways of establishing connections by providing different packages.
 
-1. 安装 Node.js 原生连接器
+1. Install Node.js Native Connector
 
-  ```
-  npm i td2.0-connector
-  ```
+```
+npm i td2.0-connector
+```
 
 :::note
-推荐 Node 版本大于等于 `node-v12.8.0` 小于 `node-v13.0.0`
-::: 
-  
-2. 安装 Node.js REST 连接器
+It's recommend to use Node whose version is between `node-v12.8.0` and `node-v13.0.0`.
+:::
 
-  ```
-  npm i td2.0-rest-connector
-  ```
+2. Install Node.js REST Connector
+
+```
+npm i td2.0-rest-connector
+```
 
 </TabItem>
 <TabItem label="C#" value="csharp">
 
-编辑项目配置文件中添加 [TDengine.Connector](https://www.nuget.org/packages/TDengine.Connector/) 的引用即可：
+Just need to add the reference to [TDengine.Connector](https://www.nuget.org/packages/TDengine.Connector/) in the project configuration file.
 
 ```xml title=csharp.csproj {12}
 <Project Sdk="Microsoft.NET.Sdk">
@@ -173,22 +174,22 @@ Node.js 连接器通过不同的包提供不同的连接方式。
 </Project>
 ```
 
-也可通过 dotnet 命令添加：
+Or add by `dotnet` command.
 
 ```
 dotnet add package TDengine.Connector
 ```
 
 :::note
-以下示例代码，均基于 dotnet6.0，如果使用其它版本，可能需要做适当调整。
+The sample code below are based on dotnet6.0, they may need to be adjusted if your dotnet version is not exactly same.
 
 :::
 
 </TabItem>
 <TabItem label="R" value="r">
 
-1. 下载 [taos-jdbcdriver-version-dist.jar](https://repo1.maven.org/maven2/com/taosdata/jdbc/taos-jdbcdriver/2.0.38/)。
-2. 安装 R 的依赖包`RJDBC`：
+1. Download [taos-jdbcdriver-version-dist.jar](https://repo1.maven.org/maven2/com/taosdata/jdbc/taos-jdbcdriver/2.0.38/).
+2. Install the dependency package `RJDBC`：
 
 ```R
 install.packages("RJDBC")
@@ -197,15 +198,15 @@ install.packages("RJDBC")
 </TabItem>
 <TabItem label="C" value="c">
 
-如果已经安装了 TDengine 服务端软件或 TDengine 客户端驱动 taosc， 那么已经安装了 C 连接器，无需额外操作。
+If the client driver taosc is already installed, then the C connector is already available.
 <br/>
 
 </TabItem>
 </Tabs>
 
-## 建立连接
+## Establish Connection
 
-在执行这一步之前，请确保有一个正在运行的，且可以访问到的 TDengine，而且服务端的 FQDN 配置正确。以下示例代码，都假设 TDengine 安装在本机，且 FQDN（默认 localhost） 和 serverPort（默认 6030） 都使用默认配置。
+Prior to establishing connection, please make sure TDengine is already running and accessible. The following sample code assumes TDengine is running on the same host as the client program, with FQDN configured to "localhost" and serverPort configured to "6030".
 
 <Tabs groupId="lang" defaultValue="java">
   <TabItem label="Java" value="java">
@@ -235,6 +236,6 @@ install.packages("RJDBC")
 </Tabs>
 
 :::tip
-如果建立连接失败，大部分情况下是 FQDN 或防火墙的配置不正确，详细的排查方法请看[《常见问题及反馈》](https://docs.taosdata.com/train-faq/faq)中的“遇到错误 Unable to establish connection, 我怎么办？”
+If the connection fails, in most cases it's caused by improper configuration for FQDN or firewall. Please refer to the section "Unable to establish connection" in [FAQ](https://docs.taosdata.com/train-faq/faq).
 
 :::
diff --git a/docs-en/04-develop/02-model/_category_.yml b/docs-en/04-develop/02-model/_category_.yml
index e5dae7c27cf17ff737aa8301bc79aad468c28791..a2b49eb879c593b29cba1b1bfab3f5b2b615c1e6 100644
--- a/docs-en/04-develop/02-model/_category_.yml
+++ b/docs-en/04-develop/02-model/_category_.yml
@@ -1,2 +1,2 @@
-label: 数据建模
+label: Data Model
 
diff --git a/docs-en/04-develop/02-model/index.mdx b/docs-en/04-develop/02-model/index.mdx
index 7cf03cee37a5ac681181b0982e98e48d139ddb83..b0b58b0a25ceae39aeb57abbad5241f28ea22930 100644
--- a/docs-en/04-develop/02-model/index.mdx
+++ b/docs-en/04-develop/02-model/index.mdx
@@ -1,87 +1,86 @@
 ---
+sidebar_label: Data Model
 slug: /model
-title: TDengine 数据建模
+title: Data Model
 ---
 
-TDengine 采用类关系型数据模型，需要建库、建表。因此对于一个具体的应用场景，需要考虑库、超级表和普通表的设计。本节不讨论细致的语法规则，只介绍概念。
+The data model employed by TDengine is similar to relational, users need to create database and tables. For a specific use case, the design of databases, stables (abbreviated for super table), and tables need to be considered. This chapter will explain the concept without syntax details.
 
-关于数据建模请参考[视频教程](https://www.taosdata.com/blog/2020/11/11/1945.html)。
+There is an [video training course](https://www.taosdata.com/blog/2020/11/11/1945.html) that can be referred to for learning purpose.
 
-## 创建库
+## Create Database
 
-不同类型的数据采集点往往具有不同的数据特征，包括数据采集频率的高低，数据保留时间的长短，副本的数目，数据块的大小，是否允许更新数据等等。为了在各种场景下 TDengine 都能最大效率的工作，TDengine 建议将不同数据特征的表创建在不同的库里，因为每个库可以配置不同的存储策略。创建一个库时，除 SQL 标准的选项外，还可以指定保留时长、副本数、内存块个数、时间精度、文件块里最大最小记录条数、是否压缩、一个数据文件覆盖的天数等多种参数。比如：
+The characteristics of data from different data collecting points may be different, such as collection frequency, days to keep, number of replicas, data block size, whether it's allowed to update data, etc. For TDengine to operate with best performance, it's strongly suggested to put the data with different characteristics into different databases because different storage policy can be set for each database. When creating a database, there are a lot of parameters that can be configured, such as the days to keep data, the number of replicas, the number of memory blocks, time precision, the minimum and maximum number of rows in each data block, compress or not, the time range of the data in single data file, etc. Below is an example of the SQL statement for creating a database.
 
 ```sql
 CREATE DATABASE power KEEP 365 DAYS 10 BLOCKS 6 UPDATE 1;
 ```
 
-上述语句将创建一个名为 power 的库，这个库的数据将保留 365 天（超过 365 天将被自动删除），每 10 天一个数据文件，内存块数为 6，允许更新数据。详细的语法及参数请见 [数据库管理](/taos-sql/database) 章节。
+In the above SQL statement, a database named "power" will be created, the data in it will be kept for 365 days, which means the data older than 365 days will be deleted automatically, a new data file will be created every 10 days, the number of memory blocks is 6, data is allowed to be updated. For more details please refer to [Database](/taos-sql/database).
 
-创建库之后，需要使用 SQL 命令 `USE` 将当前库切换过来，例如：
+After creating a database, the current database in use can be switched using SQL command `USE`, for example below SQL statement switches the current database to `power`. Without current database specified, table name must be preceded with the corresponding database name.
 
 ```sql
 USE power;
 ```
 
-将当前连接里操作的库换为 power，否则对具体表操作前，需要使用“库名.表名”来指定库的名字。
-
 :::note
 
-- 任何一张表或超级表必须属于某个库，在创建表之前，必须先创建库。
-- 处于两个不同库的表是不能进行 JOIN 操作的。
-- 创建并插入记录、查询历史记录的时候，均需要指定时间戳。
+- Any table or stable must belong to a database. To create a table or stable, the database it belongs to must be ready.
+- JOIN operation can't be performed tables from two different databases.
+- Timestamp needs to be specified when inserting rows or querying historical rows.
 
 :::
 
-## 创建超级表
+## Create STable
 
-一个物联网系统，往往存在多种类型的设备，比如对于电网，存在智能电表、变压器、母线、开关等等。为便于多表之间的聚合，使用 TDengine, 需要对每个类型的数据采集点创建一个超级表。以[表 1](/tdinternal/arch#model_table1) 中的智能电表为例，可以使用如下的 SQL 命令创建超级表：
+In a typical IoT system, there may be a lot of kinds of devices. For example, in the electrical power system there are meters, transformers, bus bars, switches, etc. For easy aggregate of multiple tables, one STable needs to be created for each kind of devices. For example, for the meters in [table 1](/tdinternal/arch#model_table1), below SQL statement can be used to create the super table.
 
 ```sql
 CREATE STABLE meters (ts timestamp, current float, voltage int, phase float) TAGS (location binary(64), groupId int);
 ```
 
 :::note
-这一指令中的 STABLE 关键字，在 2.0.15 之前的版本中需写作 TABLE 。
+If you are using versions prior to 2.0.15, the `STABLE` keyword needs to be replaced with `TABLE`.
+
 :::
 
-与创建普通表一样，创建超级表时，需要提供表名（示例中为 meters），表结构 Schema，即数据列的定义。第一列必须为时间戳（示例中为 ts)，其他列为采集的物理量（示例中为 current, voltage, phase)，数据类型可以为整型、浮点型、字符串等。除此之外，还需要提供标签的 schema (示例中为 location, groupId)，标签的数据类型可以为整型、浮点型、字符串等。采集点的静态属性往往可以作为标签，比如采集点的地理位置、设备型号、设备组 ID、管理员 ID 等等。标签的 schema 可以事后增加、删除、修改。具体定义以及细节请见 [TAOS SQL 的超级表管理](/taos-sql/stable) 章节。
+Similar to creating a normal table, when creating a stable, name and schema need to be provided too. In the stable schema, the first column must be timestamp (like ts in the example), and other columns (like current, voltage and phase in the example) are the data collected. The type of a column can be integer, floating point number, string ,etc. Besides, the schema for tags need t obe provided, like location and groupId in the example. The type of a tag can be integer, floating point number, string, etc. The static properties of a data collection point can be defined as tags, like the location, device type, device group ID, manager ID, etc. Tags in the schema can be added, removed or altered. Please refer to [STable](/taos-sql/stable) for more details.
 
-每一种类型的数据采集点需要建立一个超级表，因此一个物联网系统，往往会有多个超级表。对于电网，我们就需要对智能电表、变压器、母线、开关等都建立一个超级表。在物联网中，一个设备就可能有多个数据采集点（比如一台风力发电的风机，有的采集点采集电流、电压等电参数，有的采集点采集温度、湿度、风向等环境参数），这个时候，对这一类型的设备，需要建立多张超级表。
+Each kind of data collecting points needs a corresponding stable to be created, so there may be many stables in an IoT system. For electrical power system, we need to create a stable respectively for meters, transformers, bug bars, switches. There may be multiple kinds of data collecting points on a single device, for example there may be one data collecting point for electrical data like current and voltage and another point for environmental data like temperature, humidity and wind direction, multiple stables are required for such kind of device.
 
-一张超级表最多容许 4096 列 （在 2.1.7.0 版本之前，列数限制为 1024 列），如果一个采集点采集的物理量个数超过 4096，需要建多张超级表来处理。一个系统可以有多个 DB，一个 DB 里可以有一到多个超级表。
+At most 4096 (or 1024 prior to version 2.1.7.0) columns are allowed in a stable. If there are more than 4096 of physical variables to bo collected for a single collecting point, multiple stables are required for such kind of data collecting point. There can be multiple databases in system, while one or more stables can exist in a database.
 
-## 创建表
+## Create Table
 
-TDengine 对每个数据采集点需要独立建表。与标准的关系型数据库一样，一张表有表名，Schema，但除此之外，还可以带有一到多个标签。创建时，需要使用超级表做模板，同时指定标签的具体值。以[表 1](/tdinternal/arch#model_table1)中的智能电表为例，可以使用如下的 SQL 命令建表：
+A specific table needs to be created for each data collecting point. Similar to RDBMS, table name and schema are required to create a table. Beside, one or more tags can be created for each table. To create a table, a stable needs to be used as template and the values need to be specified for the tags. For example, for the meters in [Table 1](/tdinternal/arch#model_table1), the table can be created using below SQL statement.
 
 ```sql
 CREATE TABLE d1001 USING meters TAGS ("Beijing.Chaoyang", 2);
 ```
 
-其中 d1001 是表名，meters 是超级表的表名，后面紧跟标签 Location 的具体标签值 ”Beijing.Chaoyang"，标签 groupId 的具体标签值 2。虽然在创建表时，需要指定标签值，但可以事后修改。详细细则请见 [TAOS SQL 的表管理](/taos-sql/table) 章节。
+In the above SQL statement, "d1001" is the table name, "meters" is the stable name, followed by the value of tag "Location" and the value of tag "groupId", which are "Beijing.Chaoyang" and "2" respectively in the example. The tag values can be altered after the table is created. Please refer to [Tables](/taos-sql/table) for details.
 
 :::warning
-目前 TDengine 没有从技术层面限制使用一个 database (db1) 的超级表作为模板建立另一个 database (db2) 的子表，后续会禁止这种用法，不建议使用这种方法建表。
-
-:::
+It's not recommended to create a table in a database while using a stable from another database as template.
 
-TDengine 建议将数据采集点的全局唯一 ID 作为表名(比如设备序列号）。但对于有的场景，并没有唯一的 ID，可以将多个 ID 组合成一个唯一的 ID。不建议将具有唯一性的 ID 作为标签值。
+:::tip
+It's suggested to use the global unique ID of a data collecting point as the table name, for example the device serial number. If there isn't such a unique ID, multiple IDs that are not global unique can be combined to form a global unique ID. It's not recommended to use a global unique ID as tag value.
 
-### 自动建表
+### Create Table Automatically
 
-在某些特殊场景中，用户在写数据时并不确定某个数据采集点的表是否存在，此时可在写入数据时使用自动建表语法来创建不存在的表，若该表已存在则不会建立新表且后面的 USING 语句被忽略。比如：
+In some circumstances, it's not sure whether the table already exists when inserting rows. The table can be created automatically using the SQL statement below, and nothing will happen if the table already exist.
 
 ```sql
 INSERT INTO d1001 USING meters TAGS ("Beijng.Chaoyang", 2) VALUES (now, 10.2, 219, 0.32);
 ```
 
-上述 SQL 语句将记录`(now, 10.2, 219, 0.32)`插入表 d1001。如果表 d1001 还未创建，则使用超级表 meters 做模板自动创建，同时打上标签值 `"Beijing.Chaoyang", 2`。
+In the above SQL statement, a row with value `(now, 10.2, 219, 0.32)` will be inserted into table "d1001". If table "d1001" doesn't exist, it will be created automatically using stable "meters" as template with tag value `"Beijing.Chaoyang", 2`.
 
-关于自动建表的详细语法请参见 [插入记录时自动建表](/taos-sql/insert#插入记录时自动建表) 章节。
+For more details please refer to [Create Table Automatically](/taos-sql/insert#automatically-create-table-when-inserting).
 
-## 多列模型 vs 单列模型
+## Single Column vs Multiple Column
 
-TDengine 支持多列模型，只要物理量是一个数据采集点同时采集的（时间戳一致），这些量就可以作为不同列放在一张超级表里。但还有一种极限的设计，单列模型，每个采集的物理量都单独建表，因此每种类型的物理量都单独建立一超级表。比如电流、电压、相位，就建三张超级表。
+Multiple columns data model is supported in TDengine. As long as multiple physical variables are collected by same data collecting point at same time, i.e. the timestamp are identical, these variables can be put in single stable as columns. However, there is another kind of design, i.e. single column data model, a table is created for each physical variable, which means a stable is required for each kind of physical variables. For example, 3 stables are required for current, voltage and phase.
 
-TDengine 建议尽可能采用多列模型，因为插入效率以及存储效率更高。但对于有些场景，一个采集点的采集量的种类经常变化，这个时候，如果采用多列模型，就需要频繁修改超级表的结构定义，让应用变的复杂，这个时候，采用单列模型会显得更简单。
+It's recommended to use multiple column data model as possible because it's better in the speed of inserting or querying rows. In some cases, however, the physical variables to be collected vary frequently and correspondingly the stable schema needs to be changed frequently too. In such case, it's more convenient to use single column data model.
diff --git a/docs-en/04-develop/03-insert-data/01-sql-writing.mdx b/docs-en/04-develop/03-insert-data/01-sql-writing.mdx
index 7a4ab3eb72f6bf41e863ba26aa7ef97b503349d8..64128d8c813278d2c7c45480a5134e77149d05fa 100644
--- a/docs-en/04-develop/03-insert-data/01-sql-writing.mdx
+++ b/docs-en/04-develop/03-insert-data/01-sql-writing.mdx
@@ -1,5 +1,6 @@
 ---
-title: SQL 写入
+sidebar_label: SQL
+title: Insert Using SQL
 ---
 
 import Tabs from "@theme/Tabs";
@@ -19,52 +20,53 @@ import CsStmt from "./_cs_stmt.mdx";
 import CSQL from "./_c_sql.mdx";
 import CStmt from "./_c_stmt.mdx";
 
-## SQL 写入简介
+## Introduction
 
-应用通过连接器执行 INSERT 语句来插入数据，用户还可以通过 TAOS Shell，手动输入 INSERT 语句插入数据。
+Application program can execute `INSERT` statement through connectors to insert rows. TAOS Shell can be launched manually to insert data too.
 
-### 一次写入一条
-下面这条 INSERT 就将一条记录写入到表 d1001 中：
+### Insert Single Row
+
+Below SQL statement is used to insert one row into table "d1001".
 
 ```sql
 INSERT INTO d1001 VALUES (1538548685000, 10.3, 219, 0.31);
 ```
 
-### 一次写入多条
+### Insert Multiple Rows
 
-TDengine 支持一次写入多条记录，比如下面这条命令就将两条记录写入到表 d1001 中：
+Multiple rows can be inserted in single SQL statement. Below example inserts 2 rows into table "d1001".
 
 ```sql
 INSERT INTO d1001 VALUES (1538548684000, 10.2, 220, 0.23) (1538548696650, 10.3, 218, 0.25);
 ```
 
-### 一次写入多表
+### Insert into Multiple Tables
 
-TDengine 也支持一次向多个表写入数据，比如下面这条命令就向 d1001 写入两条记录，向 d1002 写入一条记录：
+Data can be inserted into multiple tables in same SQL statement. Below example inserts 2 rows into table "d1001" and 1 row into table "d1002".
 
 ```sql
 INSERT INTO d1001 VALUES (1538548685000, 10.3, 219, 0.31) (1538548695000, 12.6, 218, 0.33) d1002 VALUES (1538548696800, 12.3, 221, 0.31);
 ```
 
-详细的 SQL INSERT 语法规则参考 [TAOS SQL 的数据写入](/taos-sql/insert)。
+For more details about `INSERT` please refer to [INSERT](/taos-sql/insert).
 
 :::info
 
-- 要提高写入效率，需要批量写入。一批写入的记录条数越多，插入效率就越高。但一条记录不能超过 16K，一条 SQL 语句总长度不能超过 1M 。
-- TDengine 支持多线程同时写入，要进一步提高写入速度，一个客户端需要打开 20 个以上的线程同时写。但线程数达到一定数量后，无法再提高，甚至还会下降，因为线程频繁切换，带来额外开销。
+- Inserting in batch can gain better performance. Normally, the higher the batch size, the better the performance. Please be noted each single row can't exceed 16K bytes and each single SQL statement can't exceed 1M bytes.
+- Inserting with multiple threads can gain better performance too. However, depending on the system resources on the client side and the server side, with the number of inserting threads grows to a specific point, the performance may drop instead of growing. The proper number of threads need to be tested in a specific environment to find the best number.
 
 :::
 
 :::warning
 
-- 对同一张表，如果新插入记录的时间戳已经存在，默认情形下（UPDATE=0）新记录将被直接抛弃，也就是说，在一张表里，时间戳必须是唯一的。如果应用自动生成记录，很有可能生成的时间戳是一样的，这样，成功插入的记录条数会小于应用插入的记录条数。如果在创建数据库时使用了 UPDATE 1 选项，插入相同时间戳的新记录将覆盖原有记录。
-- 写入的数据的时间戳必须大于当前时间减去配置参数 keep 的时间。如果 keep 配置为 3650 天，那么无法写入比 3650 天还早的数据。写入数据的时间戳也不能大于当前时间加配置参数 days。如果 days 为 2，那么无法写入比当前时间还晚 2 天的数据。
+- If the timestamp for the row to be inserted already exists in the table, the behavior depends on the value of parameter `UPDATE`. If it's set to 0 (also the default value), the row will be discarded. If it's set to 1, the new values will override the old values for the same row.
+- The timestamp to be inserted must be newer than the timestamp of subtracting current time by the parameter `KEEP`. If `KEEP` is set to 3650 days, then the data older than 3650 days ago can't be inserted. The timestamp to be inserted can't be newer than the timestamp of current time plus parameter `DAYS`. If `DAYS` is set to 2, the data newer than 2 days later can't be inserted.
 
 :::
 
-## 示例程序
+## Examples
 
-### 普通 SQL 写入
+### Insert Using SQL
 
 <Tabs defaultValue="java" groupId="lang">
   <TabItem label="Java" value="java">
@@ -92,16 +94,16 @@ INSERT INTO d1001 VALUES (1538548685000, 10.3, 219, 0.31) (1538548695000, 12.6,
 
 :::note
 
-1. 无论 RESTful 方式建立连接还是本地驱动方式建立连接，以上示例代码都能正常工作。
-2. 唯一需要注意的是：由于 RESTful 接口无状态， 不能使用 `use db` 语句来切换数据库, 所以在上面示例中使用了`dbName.tbName`指定表名。
+1. With either native connection or REST connection, the above samples can work well.
+2. Please be noted that `use db` can't be used with REST connection because REST connection is stateless, so in the samples `dbName.tbName` is used to specify the table name.
 
 :::
 
-### 参数绑定写入
+### Insert with Parameter Binding
 
-TDengine 也提供了支持参数绑定的 Prepare API，与 MySQL 类似，这些 API 目前也仅支持用问号 `?` 来代表待绑定的参数。从 2.1.1.0 和 2.1.2.0 版本开始，TDengine 大幅改进了参数绑定接口对数据写入（INSERT）场景的支持。这样在通过参数绑定接口写入数据时，就避免了 SQL 语法解析的资源消耗，从而在绝大多数情况下显著提升写入性能。
+TDengine also provides Prepare API that support parameter binding. Similar to MySQL, only `?` can be used in these APIs to represent the parameters to bind. From version 2.1.1.0 and 2.1.2.0, parameter binding support for inserting data has been improved significantly to improve the insert performance by avoiding the cost of parsing SQL statements.
 
-需要注意的是，只有使用原生连接的连接器，才能使用参数绑定功能。
+Parameter binding is available only with native connection.
 
 <Tabs defaultValue="java" groupId="lang">
   <TabItem label="Java" value="java">
@@ -126,4 +128,3 @@ TDengine 也提供了支持参数绑定的 Prepare API，与 MySQL 类似，这
     <CStmt />
   </TabItem>
 </Tabs>
-
diff --git a/docs-en/04-develop/03-insert-data/02-influxdb-line.mdx b/docs-en/04-develop/03-insert-data/02-influxdb-line.mdx
index dedd7f0e70834e21257bda78dd184f5ddc520160..c22dc0b59d2acab9dfaf2ef3f919513245b403dd 100644
--- a/docs-en/04-develop/03-insert-data/02-influxdb-line.mdx
+++ b/docs-en/04-develop/03-insert-data/02-influxdb-line.mdx
@@ -1,6 +1,6 @@
 ---
-sidebar_label: InfluxDB 行协议
-title: InfluxDB 行协议
+sidebar_label: InfluxDB Line Protocol
+title: Insert with InfluxDB Line Protocol
 ---
 
 import Tabs from "@theme/Tabs";
@@ -13,20 +13,20 @@ import NodeLine from "./_js_line.mdx";
 import CsLine from "./_cs_line.mdx";
 import CLine from "./_c_line.mdx";
 
-## 协议介绍
+## Introduction
 
-InfluxDB Line 协议采用一行字符串来表示一行数据。分为四部分：
+A single line of text is used in InfluxDB Line protocol format represents one row of data, each line contains 4 parts as shown below.
 
 ```
 measurement,tag_set field_set timestamp
 ```
 
-- measurement 将作为超级表名。它与 tag_set 之间使用一个英文逗号来分隔。
-- tag_set 将作为标签数据，其格式形如 `<tag_key>=<tag_value>,<tag_key>=<tag_value>`，也即可以使用英文逗号来分隔多个标签数据。它与 field_set 之间使用一个半角空格来分隔。
-- field_set 将作为普通列数据，其格式形如 `<field_key>=<field_value>,<field_key>=<field_value>`，同样是使用英文逗号来分隔多个普通列的数据。它与 timestamp 之间使用一个半角空格来分隔。
-- timestamp 即本行数据对应的主键时间戳。
+- `measurement` will be used as the stable name
+- `tag_set` will be used as tags, with format like `<tag_key>=<tag_value>,<tag_key>=<tag_value>`
+- `field_set`will be used as data columns, with format like `<field_key>=<field_value>,<field_key>=<field_value>`
+- `timestamp`  is the primary key timestamp corresponding to this row of data
 
-例如：
+For example:
 
 ```
 meters,location=Beijing.Haidian,groupid=2 current=13.4,voltage=223,phase=0.29 1648432611249500
@@ -34,16 +34,16 @@ meters,location=Beijing.Haidian,groupid=2 current=13.4,voltage=223,phase=0.29 16
 
 :::note
 
-- tag_set 中的所有的数据自动转化为 nchar 数据类型;
-- field_set 中的每个数据项都需要对自身的数据类型进行描述, 比如 1.2f32 代表 float 类型的数值 1.2, 如果不带类型后缀会被当作 double 处理;
-- timestamp 支持多种时间精度。写入数据的时候需要用参数指定时间精度，支持从小时到纳秒的 6 种时间精度。
+- All the data in `tag_set` will be converted to ncahr type automatically .
+- Each data in `field_set` must be self-description for its data type. For example 1.2f32 means a value 1.2 of float type, it will be treated as double without the "f" type suffix.
+- Multiple kinds of precision can be used for the `timestamp` field. Time precision can be from nanosecond (ns) to hour (h).
 
 :::
 
-要了解更多可参考：[InfluxDB Line 协议官方文档](https://docs.influxdata.com/influxdb/v2.0/reference/syntax/line-protocol/) 和 [TDengine 无模式写入参考指南](/reference/schemaless/#无模式写入行协议)
+For more details please refer to [InfluxDB Line Protocol](https://docs.influxdata.com/influxdb/v2.0/reference/syntax/line-protocol/) and [TDengine Schemaless](/reference/schemaless/#Schemaless-Line-Protocol)
 
 
-## 示例代码
+## Examples
 
 <Tabs defaultValue="java" groupId="lang">
   <TabItem label="Java" value="java">
diff --git a/docs-en/04-develop/03-insert-data/03-opentsdb-telnet.mdx b/docs-en/04-develop/03-insert-data/03-opentsdb-telnet.mdx
index dfbe6efda67b6928999287900637e0a251b86562..ca06a906c2162faaf63e7ace967310ff8d6dddf1 100644
--- a/docs-en/04-develop/03-insert-data/03-opentsdb-telnet.mdx
+++ b/docs-en/04-develop/03-insert-data/03-opentsdb-telnet.mdx
@@ -1,6 +1,6 @@
 ---
-sidebar_label: OpenTSDB 行协议
-title: OpenTSDB 行协议
+sidebar_label: OpenTSDB Line Protocol
+title: OpenTSDB Line Protocol
 ---
 
 import Tabs from "@theme/Tabs";
@@ -13,28 +13,28 @@ import NodeTelnet from "./_js_opts_telnet.mdx";
 import CsTelnet from "./_cs_opts_telnet.mdx";
 import CTelnet from "./_c_opts_telnet.mdx";
 
-## 协议介绍
+## Introduction
 
-OpenTSDB 行协议同样采用一行字符串来表示一行数据。OpenTSDB 采用的是单列模型，因此一行只能包含一个普通数据列。标签列依然可以有多个。分为四部分，具体格式约定如下：
+A single line of text is used in OpenTSDB line protocol to represent one row of data. OpenTSDB employs single column data model, so one line can only contains single data column. There can be multiple tags. Each line contains 4 parts as below:
 
-```txt
+```
 <metric> <timestamp> <value> <tagk_1>=<tagv_1>[ <tagk_n>=<tagv_n>]
 ```
 
-- metric 将作为超级表名。
-- timestamp 本行数据对应的时间戳。根据时间戳的长度自动识别时间精度。支持秒和毫秒两种时间精度
-- value 度量值，必须为一个数值。对应的列名也是 “value”。
-- 最后一部分是标签集， 用空格分隔不同标签， 所有标签自动转化为 nchar 数据类型;
+- `metric` will be used as stable name.
+- `timestamp` is the timestamp of current row of data. The time precision will be determined automatically based on the length of the timestamp. second and millisecond time precision are supported.\
+- `value` is a physical variable which must be a numeric value, the corresponding column name is "value".
+- The last part is tag sets separated by space, all tags will be converted to nchar type automatically.
 
-例如：
+For example:
 
 ```txt
 meters.current 1648432611250 11.3 location=Beijing.Haidian groupid=3
 ```
 
-参考[OpenTSDB Telnet API文档](http://opentsdb.net/docs/build/html/api_telnet/put.html)。
+Please refer to [OpenTSDB Telnet API](http://opentsdb.net/docs/build/html/api_telnet/put.html) for more details.
 
-## 示例代码
+## Examples
 
 <Tabs defaultValue="java" groupId="lang">
   <TabItem label="Java" value="java">
@@ -60,7 +60,7 @@ meters.current 1648432611250 11.3 location=Beijing.Haidian groupid=3
   </TabItem>
 </Tabs>
 
-以上示例代码会自动创建 2 个超级表， 每个超级表有 4 条数据。
+2 stables will be crated automatically while each stable has 4 rows of data in the above sample code.
 
 ```cmd
 taos> use test;
diff --git a/docs-en/04-develop/03-insert-data/04-opentsdb-json.mdx b/docs-en/04-develop/03-insert-data/04-opentsdb-json.mdx
index 5d445997d061ca052e4f3673b8e881ea4acf0ade..a4d084bff6c997b9431c0a9d25a1fec9938090b4 100644
--- a/docs-en/04-develop/03-insert-data/04-opentsdb-json.mdx
+++ b/docs-en/04-develop/03-insert-data/04-opentsdb-json.mdx
@@ -1,6 +1,6 @@
 ---
-sidebar_label: OpenTSDB JSON 格式协议
-title: OpenTSDB JSON 格式协议
+sidebar_label: OpenTSDB JSON Protocol
+title: OpenTSDB JSON Protocol
 ---
 
 import Tabs from "@theme/Tabs";
@@ -13,9 +13,9 @@ import NodeJson from "./_js_opts_json.mdx";
 import CsJson from "./_cs_opts_json.mdx";
 import CJson from "./_c_opts_json.mdx";
 
-## 协议介绍
+## Introduction
 
-OpenTSDB JSON 格式协议采用一个 JSON 字符串表示一行或多行数据。例如：
+A JSON string is sued in OpenTSDB JSON to represent one or more rows of data, for exmaple:
 
 ```json
 [
@@ -40,18 +40,18 @@ OpenTSDB JSON 格式协议采用一个 JSON 字符串表示一行或多行数据
 ]
 ```
 
-与 OpenTSDB 行协议类似， metric 将作为超级表名， timestamp 表示时间戳，value 表示度量值， tags 表示标签集。
+Similar to OpenTSDB line protocol, `metric` will be used as the stable name, `timestamp` is the timestamp to be used, `value` represents the physical variable collected, `tags` are the tag sets.
 
 
-参考[OpenTSDB HTTP API文档](http://opentsdb.net/docs/build/html/api_http/put.html)。
+Please refer to [OpenTSDB HTTP API](http://opentsdb.net/docs/build/html/api_http/put.html) for more details.
 
 :::note
-- 对于 JSON 格式协议，TDengine 并不会自动把所有标签转成 nchar 类型， 字符串将将转为 nchar 类型， 数值将同样转换为 double 类型。
-- TDengine 只接收 JSON **数组格式**的字符串，即使一行数据也需要转换成数组形式。
+- In JSON protocol, strings will be converted to nchar type and numeric values will be converted to double type.
+- Only data in array format is accepted, array must be used even there is only one row.
 
 :::
 
-## 示例代码
+## Examples
 
 <Tabs defaultValue="java" groupId="lang">
   <TabItem label="Java" value="java">
@@ -77,7 +77,7 @@ OpenTSDB JSON 格式协议采用一个 JSON 字符串表示一行或多行数据
   </TabItem>
 </Tabs>
 
-以上示例代码会自动创建 2 个超级表， 每个超级表有 2 条数据。
+The above sample code will created 2 stables automatically while each stable has 2 rows of data.
 
 ```cmd
 taos> use test;
diff --git a/docs-en/04-develop/03-insert-data/_c_stmt.mdx b/docs-en/04-develop/03-insert-data/_c_stmt.mdx
index 01ac067519a2bd224e313fd70169722ba5f20413..7f5ef23a849689c36e732b6fd374a131695c9090 100644
--- a/docs-en/04-develop/03-insert-data/_c_stmt.mdx
+++ b/docs-en/04-develop/03-insert-data/_c_stmt.mdx
@@ -1,6 +1,6 @@
-```c title=一次绑定一行
+```c title=Single Row Binding
 {{#include docs-examples/c/stmt_example.c}}
 ```
-```c title=一次绑定多行 72:117
+```c title=Multiple Row Binding 72:117
 {{#include docs-examples/c/multi_bind_example.c}}
 ```
\ No newline at end of file
diff --git a/docs-en/04-develop/03-insert-data/_category_.yml b/docs-en/04-develop/03-insert-data/_category_.yml
index 9e76a57abd132b528bbd692f03439649ab83425d..8f42ee1a417aaee469f8284f09df0f51c40fd1f7 100644
--- a/docs-en/04-develop/03-insert-data/_category_.yml
+++ b/docs-en/04-develop/03-insert-data/_category_.yml
@@ -1,5 +1,5 @@
-label: 写入数据
+label: Insert
 link:
   type: generated-index
   slug: /insert-data/
-  description: "TDengine 支持多种写入协议，包括 SQL，InfluxDB Line 协议, OpenTSDB Telnet 协议，OpenTSDB JSON 格式协议。数据可以单条插入，也可以批量插入，可以插入一个数据采集点的数据，也可以同时插入多个数据采集点的数据。同时，TDengine 支持多线程插入，支持时间乱序数据插入，也支持历史数据插入。InfluxDB Line 协议、OpenTSDB Telnet 协议和 OpenTSDB JSON 格式协议是 TDengine 支持的三种无模式写入协议。使用无模式方式写入无需提前创建超级表和子表，并且引擎能自适用数据对表结构做调整。"
+  description: "TDengine supports multiple protocols of inserting data, including SQL, InfluxDB Line protocol, OpenTSDB Telnet protocol, OpenTSDB JSON protocol. Data can be inserted row by row, or in batch. Data from one or more collecting points can be inserted simultaneously. In the meantime, data can be inserted with multiple threads, out of order data and historical data can be inserted too. InfluxDB Line protocol, OpenTSDB Telnet protocol and OpenTSDB JSON protocol are the 3 kinds of schemaless insert protocols supported by TDengine. It's not necessary to create stable and table in advance if using schemaless protocols, and the schemas can be adjusted automatically according to the data to be inserted."
diff --git a/docs-en/04-develop/03-insert-data/_go_stmt.mdx b/docs-en/04-develop/03-insert-data/_go_stmt.mdx
index 7bb6792d6df5b250850bd0a0021ecceba994aa09..c32bc21fb9bcaf45059e4f47df73fb57f047ed1c 100644
--- a/docs-en/04-develop/03-insert-data/_go_stmt.mdx
+++ b/docs-en/04-develop/03-insert-data/_go_stmt.mdx
@@ -3,6 +3,6 @@
 ```
 
 :::tip
-driver-go 的模块 `github.com/taosdata/driver-go/v2/wrapper` 是 C 接口的底层封装。使用这个模块也可以实现参数绑定写入。
+`github.com/taosdata/driver-go/v2/wrapper` module in driver-go is the wrapper for C API, it can be used to insert data with parameter binding.
 
 :::
diff --git a/docs-en/04-develop/03-insert-data/_js_stmt.mdx b/docs-en/04-develop/03-insert-data/_js_stmt.mdx
index 17a6c9785c7dc1e3c3fa6a59982913f1f139f9c2..964d7ddc11b90031b70936efb85fbaabe873ddbb 100644
--- a/docs-en/04-develop/03-insert-data/_js_stmt.mdx
+++ b/docs-en/04-develop/03-insert-data/_js_stmt.mdx
@@ -1,12 +1,12 @@
-```js title=一次绑定一行
+```js title=Single Row Binding
 {{#include docs-examples/node/nativeexample/param_bind_example.js}}
 ```
 
-```js title=一次绑定多行
+```js title=Multiple Row Binding
 {{#include docs-examples/node/nativeexample/multi_bind_example.js:insertData}}
 ```
 
 :::info
-一次绑定一行效率不如一次绑定多行，但支持非 INSERT 语句。一次绑定多行效率更高，但仅支持 INSERT 语句。
+Multiple row binding is better in performance than single row binding, but it can only be used with `INSERT` statement while single row binding can be used for other SQL statements besides `INSERT`.
 
 :::
diff --git a/docs-en/04-develop/03-insert-data/_py_stmt.mdx b/docs-en/04-develop/03-insert-data/_py_stmt.mdx
index 8241ea86bc64ac64d842dc0a6cddc0eae0399503..16d98f54329ad0d3dfb463392f5c1d41c9aab25b 100644
--- a/docs-en/04-develop/03-insert-data/_py_stmt.mdx
+++ b/docs-en/04-develop/03-insert-data/_py_stmt.mdx
@@ -1,12 +1,12 @@
-```py title=一次绑定一行
+```py title=Single Row Binding
 {{#include docs-examples/python/bind_param_example.py}}
 ```
 
-```py title=一次绑定多行
+```py title=Multiple Row Binding
 {{#include docs-examples/python/multi_bind_example.py:bind_batch}}
 ```
 
 :::info
-一次绑定一行效率不如一次绑定多行，但支持非 INSERT 语句。一次绑定多行效率更高，但仅支持 INSERT 语句。
+Multiple row binding is better in performance than single row binding, but it can only be used with `INSERT` statement while single row binding can be used for other SQL statements besides `INSERT`.
 
 :::
\ No newline at end of file
diff --git a/docs-en/04-develop/_sub_java.mdx b/docs-en/04-develop/_sub_java.mdx
index 1ee0cb1a21e35f6760f8680e2ba6dedee92201cd..e65bc576ebed030d935ced6a4572289cd367ffac 100644
--- a/docs-en/04-develop/_sub_java.mdx
+++ b/docs-en/04-develop/_sub_java.mdx
@@ -2,6 +2,6 @@
 {{#include docs-examples/java/src/main/java/com/taos/example/SubscribeDemo.java}}
 ```
 :::note
-目前 Java 接口没有提供异步订阅模式，但用户程序可以通过创建 `TimerTask` 等方式达到同样的效果。
+For now Java connector doesn't provide asynchronous subscription, but `TimerTask` can be used to achieve similar purpose.
 
 :::
\ No newline at end of file