diff --git a/go/colonio/colonio.c b/go/colonio/colonio.c
index b5d7f330..dd9efa85 100644
--- a/go/colonio/colonio.c
+++ b/go/colonio/colonio.c
@@ -32,9 +32,10 @@ void cgo_wrap_colonio_logger(colonio_t colonio, const char* message, unsigned in
   cgoWrapColonioLogger(colonio, (void*)message, (int)len);
 }
 
-colonio_error_t* cgo_colonio_init(colonio_t* colonio, int v, unsigned int u) {
+colonio_error_t* cgo_colonio_init(colonio_t* colonio, unsigned int timeout, int v, unsigned int u) {
   colonio_config_t config;
   colonio_config_set_default(&config);
+  config.seed_session_timeout_ms   = timeout;
   config.disable_seed_verification = v == 1 ? true : false;
   config.max_user_threads          = u;
   config.logger_func               = cgo_wrap_colonio_logger;
diff --git a/go/colonio/colonio_native.go b/go/colonio/colonio_native.go
index dac23279..ad066fe0 100644
--- a/go/colonio/colonio_native.go
+++ b/go/colonio/colonio_native.go
@@ -34,7 +34,7 @@ typedef void* colonio_t;
 typedef void* colonio_value_t;
 
 // colonio
-colonio_error_t* cgo_colonio_init(colonio_t* colonio, int v, unsigned int u);
+colonio_error_t* cgo_colonio_init(colonio_t* colonio, unsigned int timeout, int v, unsigned int u);
 colonio_error_t* cgo_colonio_connect(colonio_t colonio, _GoString_ url, _GoString_ token);
 int cgo_colonio_is_connected(colonio_t colonio);
 
@@ -116,6 +116,7 @@ func convertError(errC *C.struct_colonio_error_s) error {
 
 func NewConfig() *ColonioConfig {
 	return &ColonioConfig{
+		SeedSessionTimeoutMs:    30 * 1000,
 		DisableSeedVerification: false,
 		MaxUserThreads:          1,
 		LoggerFunc: func(s string) {
@@ -140,7 +141,7 @@ func NewColonio(config *ColonioConfig) (Colonio, error) {
 	if config.DisableSeedVerification {
 		v = 1
 	}
-	errC := C.cgo_colonio_init(&impl.colonioC, C.int(v), C.uint(config.MaxUserThreads))
+	errC := C.cgo_colonio_init(&impl.colonioC, C.uint(config.SeedSessionTimeoutMs), C.int(v), C.uint(config.MaxUserThreads))
 	if errC != nil {
 		return nil, convertError(errC)
 	}
diff --git a/go/colonio/colonio_wasm.go b/go/colonio/colonio_wasm.go
index 68f100e0..9ee523bf 100644
--- a/go/colonio/colonio_wasm.go
+++ b/go/colonio/colonio_wasm.go
@@ -173,6 +173,7 @@ func onResponse(_ js.Value, args []js.Value) interface{} {
 
 func NewConfig() *ColonioConfig {
 	return &ColonioConfig{
+		SeedSessionTimeoutMs:    30 * 1000,
 		DisableSeedVerification: false,
 		MaxUserThreads:          1,
 		LoggerFunc: func(s string) {
@@ -185,6 +186,7 @@ func NewConfig() *ColonioConfig {
 func NewColonio(config *ColonioConfig) (Colonio, error) {
 	impl := &colonioImpl{
 		colonioJ: helperJ.Call("newColonio",
+			js.ValueOf(config.SeedSessionTimeoutMs),
 			js.ValueOf(config.DisableSeedVerification),
 			js.FuncOf(func(this js.Value, args []js.Value) interface{} {
 				config.LoggerFunc(args[0].String())
diff --git a/go/colonio/types.go b/go/colonio/types.go
index cbf0e6b3..ae741484 100644
--- a/go/colonio/types.go
+++ b/go/colonio/types.go
@@ -46,6 +46,7 @@ const (
 )
 
 type ColonioConfig struct {
+	SeedSessionTimeoutMs    uint
 	DisableSeedVerification bool
 	MaxUserThreads          uint
 	LoggerFunc              func(string)
diff --git a/go/seed/config.go b/go/seed/config.go
index d6dc9860..93f3c7dd 100644
--- a/go/seed/config.go
+++ b/go/seed/config.go
@@ -72,15 +72,14 @@ type ConfigNode struct {
 }
 
 type Config struct {
-	Revision         float64     `json:"revision,omitempty"`
-	KeepAliveTimeout int64       `json:"keepAliveTimeout"`
-	PollingTimeout   int64       `json:"pollingTimeout"`
-	Node             *ConfigNode `json:"node,omitempty"`
+	SessionTimeout int64       `json:"sessionTimeout"`
+	PollingTimeout int64       `json:"pollingTimeout"`
+	Node           *ConfigNode `json:"node,omitempty"`
 }
 
 func (c *Config) validate() error {
-	if c.KeepAliveTimeout <= 0 {
-		return errors.New("Config value of `keepAliveTimeout` must be larger then 0")
+	if c.SessionTimeout <= 0 {
+		return errors.New("Config value of `sessionTimeout` must be larger then 0")
 	}
 
 	if c.PollingTimeout <= 0 {
diff --git a/go/seed/seed.go b/go/seed/seed.go
index 2b7300ea..1a3311cb 100644
--- a/go/seed/seed.go
+++ b/go/seed/seed.go
@@ -72,9 +72,9 @@ type Seed struct {
 	// packets to relay
 	packets []packet
 
-	config           string
-	keepAliveTimeout time.Duration
-	pollingTimeout   time.Duration
+	config         string
+	sessionTimeout time.Duration
+	pollingTimeout time.Duration
 
 	verifier TokenVerifier
 }
@@ -89,20 +89,19 @@ func NewSeed(config *Config, verifier TokenVerifier) (*Seed, error) {
 	}
 
 	nodeConfig := config.Node
-	nodeConfig.Revision = config.Revision
 	nodeConfigJS, err := json.Marshal(nodeConfig)
 	if err != nil {
 		return nil, err
 	}
 
 	seed := &Seed{
-		mutex:            sync.Mutex{},
-		nodes:            make(map[string]*node),
-		sessions:         make(map[string]string),
-		config:           string(nodeConfigJS),
-		keepAliveTimeout: time.Duration(config.KeepAliveTimeout) * time.Millisecond,
-		pollingTimeout:   time.Duration(config.PollingTimeout) * time.Millisecond,
-		verifier:         verifier,
+		mutex:          sync.Mutex{},
+		nodes:          make(map[string]*node),
+		sessions:       make(map[string]string),
+		config:         string(nodeConfigJS),
+		sessionTimeout: time.Duration(config.SessionTimeout) * time.Millisecond,
+		pollingTimeout: time.Duration(config.PollingTimeout) * time.Millisecond,
+		verifier:       verifier,
 	}
 
 	mux := http.NewServeMux()
@@ -478,7 +477,7 @@ func (seed *Seed) cleanup() error {
 		}
 
 		// disconnect node if it had pass keep alive timeout
-		if now.After(node.timestamp.Add(seed.keepAliveTimeout)) {
+		if now.After(node.timestamp.Add(seed.sessionTimeout)) {
 			seed.disconnect(nid, true)
 		}
 	}
diff --git a/go/seed/seed_test.go b/go/seed/seed_test.go
index 0f5b820c..09268a83 100644
--- a/go/seed/seed_test.go
+++ b/go/seed/seed_test.go
@@ -30,11 +30,11 @@ import (
 
 func generateEmptySeed() *Seed {
 	return &Seed{
-		mutex:            sync.Mutex{},
-		nodes:            make(map[string]*node),
-		sessions:         make(map[string]string),
-		keepAliveTimeout: 30 * time.Second,
-		pollingTimeout:   10 * time.Second,
+		mutex:          sync.Mutex{},
+		nodes:          make(map[string]*node),
+		sessions:       make(map[string]string),
+		sessionTimeout: 30 * time.Second,
+		pollingTimeout: 10 * time.Second,
 	}
 }
 
diff --git a/go/test/seed.json b/go/test/seed.json
index f4aa6664..35dc0a83 100644
--- a/go/test/seed.json
+++ b/go/test/seed.json
@@ -6,6 +6,7 @@
     "/colonio_go.js": "../../src/js/"
   },
   "node": {
+    "revision": 20201121.1,
     "coordSystem2D": {
       "type": "sphere",
       "radius": 6378137
@@ -27,10 +28,9 @@
   },
   "path": "/test",
   "port": 8080,
-  "keepAliveTimeout": 30000,
-  "PollingTimeout": 10000,
+  "sessionTimeout": 30000,
+  "pollingTimeout": 10000,
   "certFile": "../../localhost.crt",
   "keyFile": "../../localhost.key",
-  "useTcp": true,
-  "revision": 20201121.1
+  "useTcp": true
 }
\ No newline at end of file
diff --git a/src/colonio/colonio.h b/src/colonio/colonio.h
index 64747370..7cac1069 100644
--- a/src/colonio/colonio.h
+++ b/src/colonio/colonio.h
@@ -114,6 +114,7 @@ typedef struct colonio_config_s {
   bool disable_callback_thread;
   bool disable_seed_verification;
   unsigned int max_user_threads;
+  unsigned int seed_session_timeout_ms;
   void (*logger_func)(colonio_t, const char*, unsigned int);
 } colonio_config_t;
 
diff --git a/src/colonio/colonio.hpp b/src/colonio/colonio.hpp
index 3394e2d0..642b4a45 100644
--- a/src/colonio/colonio.hpp
+++ b/src/colonio/colonio.hpp
@@ -312,6 +312,16 @@ class ColonioConfig {
    */
   unsigned int max_user_threads;
 
+  /**
+   * @brief `session_timeout_ms` describes the timeout of session between node with the seed.
+   *
+   * After timeout from last translate between the seed, the session infomation will be cleared and will be send
+   * authenticate packet before other packet to the seed.
+   *
+   * default: 30000
+   */
+  unsigned int seed_session_timeout_ms;
+
   /**
    * @brief `logger` is for customizing the the log receiver.
    *
diff --git a/src/core/colonio.cpp b/src/core/colonio.cpp
index 49052839..c126ba4e 100644
--- a/src/core/colonio.cpp
+++ b/src/core/colonio.cpp
@@ -50,6 +50,7 @@ ColonioConfig::ColonioConfig() :
     disable_callback_thread(false),
     disable_seed_verification(false),
     max_user_threads(1),
+    seed_session_timeout_ms(30 * 1000),
     logger_func(default_logger_func) {
 }
 
diff --git a/src/core/colonio_impl.cpp b/src/core/colonio_impl.cpp
index 8b3b3812..6d2085f9 100644
--- a/src/core/colonio_impl.cpp
+++ b/src/core/colonio_impl.cpp
@@ -564,7 +564,8 @@ void ColonioImpl::allocate_resources() {
   coord_system.reset();
   command_manager = std::make_unique<CommandManager>(logger, random, *scheduler, local_nid, *this);
   network         = std::make_unique<Network>(
-      logger, random, *scheduler, *command_manager, local_nid, *this, local_config.disable_seed_verification);
+      logger, random, *scheduler, *command_manager, local_nid, *this, local_config.seed_session_timeout_ms,
+      local_config.disable_seed_verification);
   messaging.reset();
 }
 
diff --git a/src/core/definition.hpp b/src/core/definition.hpp
index 10bcd0a4..85a1ac5e 100644
--- a/src/core/definition.hpp
+++ b/src/core/definition.hpp
@@ -97,7 +97,6 @@ static const unsigned int FIRST_LINK_RETRY_MAX   = 3;
 static const int64_t LINK_TRIAL_TIME_MIN         = 60000;
 static const unsigned int LINKS_MIN              = 4;
 static const int64_t SEED_CONNECT_INTERVAL       = 10000;
-static const int64_t SEED_SESSION_TIMEOUT        = 10 * 1000;  // [msec]
 static const uint32_t PACKET_ID_NONE             = 0x0;
 
 }  // namespace colonio
diff --git a/src/core/export_c.cpp b/src/core/export_c.cpp
index adcc43bc..34ac5489 100644
--- a/src/core/export_c.cpp
+++ b/src/core/export_c.cpp
@@ -46,6 +46,7 @@ void colonio_config_set_default(colonio_config_t* config) {
   config->disable_callback_thread   = false;
   config->disable_seed_verification = false;
   config->max_user_threads          = 1;
+  config->seed_session_timeout_ms   = 30 * 1000;
   config->logger_func               = nullptr;
 }
 
@@ -59,6 +60,7 @@ colonio_error_t* colonio_init(colonio_t* c, const colonio_config_t* cf) {
     config.disable_callback_thread   = cf->disable_callback_thread;
     config.disable_seed_verification = cf->disable_seed_verification;
     config.max_user_threads          = cf->max_user_threads;
+    config.seed_session_timeout_ms   = cf->seed_session_timeout_ms;
     if (cf->logger_func != nullptr) {
       auto f             = cf->logger_func;
       config.logger_func = [c, f](Colonio& _, const std::string& json) {
diff --git a/src/core/network.cpp b/src/core/network.cpp
index b1696820..8d90c318 100644
--- a/src/core/network.cpp
+++ b/src/core/network.cpp
@@ -27,7 +27,10 @@ namespace colonio {
 NetworkDelegate::~NetworkDelegate() {
 }
 
-Network::Network(Logger& l, Random& r, Scheduler& s, CommandManager& c, const NodeID& n, NetworkDelegate& d, bool v) :
+Network::Network(
+    Logger& l, Random& r, Scheduler& s, CommandManager& c, const NodeID& n, NetworkDelegate& d, unsigned int timeout,
+    bool v) :
+    SEED_SESSION_TIMEOUT(timeout),
     DISABLE_SEED_VERIFICATION(v),
     logger(l),
     random(r),
@@ -60,8 +63,8 @@ void Network::connect(
 
     enforce_online = true;
 
-    seed_accessor =
-        std::make_unique<SeedAccessor>(logger, scheduler, local_nid, *this, url, token, DISABLE_SEED_VERIFICATION);
+    seed_accessor = std::make_unique<SeedAccessor>(
+        logger, scheduler, local_nid, *this, url, token, SEED_SESSION_TIMEOUT, DISABLE_SEED_VERIFICATION);
     node_accessor = std::make_unique<NodeAccessor>(logger, scheduler, command_manager, local_nid, *this);
 
     scheduler.add_task(this, std::bind(&Network::update_accessor_state, this));
diff --git a/src/core/network.hpp b/src/core/network.hpp
index 3a15b870..c526222b 100644
--- a/src/core/network.hpp
+++ b/src/core/network.hpp
@@ -43,7 +43,9 @@ class NetworkDelegate {
 
 class Network : public NodeAccessorDelegate, public RoutingDelegate, public SeedAccessorDelegate {
  public:
-  Network(Logger& l, Random& r, Scheduler& s, CommandManager& c, const NodeID& n, NetworkDelegate&, bool v);
+  Network(
+      Logger& l, Random& r, Scheduler& s, CommandManager& c, const NodeID& n, NetworkDelegate&, unsigned int timeout,
+      bool v);
   virtual ~Network();
 
   void connect(
@@ -59,6 +61,7 @@ class Network : public NodeAccessorDelegate, public RoutingDelegate, public Seed
   const NodeID& get_relay_nid_2d(const Coordinate& position);
 
  private:
+  const unsigned int SEED_SESSION_TIMEOUT;
   const bool DISABLE_SEED_VERIFICATION;
 
   Logger& logger;
diff --git a/src/core/seed_accessor.cpp b/src/core/seed_accessor.cpp
index 076e385f..6c43ed84 100644
--- a/src/core/seed_accessor.cpp
+++ b/src/core/seed_accessor.cpp
@@ -37,12 +37,13 @@ SeedAccessorDelegate::~SeedAccessorDelegate() {
 
 SeedAccessor::SeedAccessor(
     Logger& l, Scheduler& s, const NodeID& n, SeedAccessorDelegate& d, const std::string& u, const std::string& t,
-    bool v) :
+    unsigned int timeout, bool v) :
     logger(l),
     scheduler(s),
     local_nid(n),
     delegate(d),
     token(t),
+    SESSION_TIMEOUT(timeout),
     polling_flag(false),
     running_auth(false),
     is_online(false),
@@ -130,7 +131,7 @@ void SeedAccessor::trigger() {
 
   // disconnect when polling is off and waiting queue is empty
   if (!polling_flag && waiting.empty() && last_send_time != 0) {
-    if (last_send_time + SEED_SESSION_TIMEOUT < Utils::get_current_msec() && !session.empty()) {
+    if (last_send_time + SESSION_TIMEOUT < Utils::get_current_msec() && !session.empty()) {
       disconnect();
     }
     return;
diff --git a/src/core/seed_accessor.hpp b/src/core/seed_accessor.hpp
index 109c864c..21a26a0f 100644
--- a/src/core/seed_accessor.hpp
+++ b/src/core/seed_accessor.hpp
@@ -61,7 +61,7 @@ class SeedAccessor {
  public:
   SeedAccessor(
       Logger& l, Scheduler& s, const NodeID& n, SeedAccessorDelegate& d, const std::string& u, const std::string& t,
-      bool v);
+      unsigned int timeout, bool v);
   virtual ~SeedAccessor();
   SeedAccessor(const SeedAccessor&) = delete;
   SeedAccessor& operator=(const SeedAccessor&) = delete;
@@ -82,6 +82,8 @@ class SeedAccessor {
   SeedAccessorDelegate& delegate;
 
   const std::string token;
+  const unsigned int SESSION_TIMEOUT;
+
   /** Connection to the server */
   std::unique_ptr<SeedLink> link;
   // session id. it is empty if session disabled
diff --git a/src/js/colonio_go.js b/src/js/colonio_go.js
index 96d2cc02..f2b25d02 100644
--- a/src/js/colonio_go.js
+++ b/src/js/colonio_go.js
@@ -20,8 +20,9 @@ class ColonioGo {
     constructor(mod) {
         this.mod = mod;
     }
-    newColonio(v, logger) {
+    newColonio(timeout, v, logger) {
         let config = new this.mod.ColonioConfig();
+        config.seedSessionTimeoutMs = timeout;
         config.disableSeedVerification = v;
         config.loggerFuncRaw = (_, log) => {
             logger(log);
diff --git a/src/js/colonio_go.ts b/src/js/colonio_go.ts
index eac1f3ba..da9153ac 100644
--- a/src/js/colonio_go.ts
+++ b/src/js/colonio_go.ts
@@ -24,8 +24,9 @@ class ColonioGo {
     this.mod = mod;
   }
 
-  newColonio(v: boolean, logger: (log: string) => void): Colonio {
+  newColonio(timeout: number, v: boolean, logger: (log: string) => void): Colonio {
     let config = new this.mod.ColonioConfig();
+    config.seedSessionTimeoutMs = timeout;
     config.disableSeedVerification = v;
     config.loggerFuncRaw = (_: Colonio, log: string): void => {
       logger(log);
diff --git a/src/js/core.d.ts b/src/js/core.d.ts
index 7fbda63c..4e1ff8d6 100644
--- a/src/js/core.d.ts
+++ b/src/js/core.d.ts
@@ -79,6 +79,7 @@ declare class Value {
     write(valueC?: number): number;
 }
 declare class ColonioConfig {
+    seedSessionTimeoutMs: number;
     disableSeedVerification: boolean;
     loggerFuncRaw: (c: Colonio, json: string) => void;
     loggerFunc: (c: Colonio, log: LogEntry) => void;
diff --git a/src/js/core.ts b/src/js/core.ts
index 6f498b89..b37d3360 100644
--- a/src/js/core.ts
+++ b/src/js/core.ts
@@ -377,11 +377,13 @@ class Value {
 }
 
 class ColonioConfig {
+  seedSessionTimeoutMs: number;
   disableSeedVerification: boolean;
   loggerFuncRaw: (c: Colonio, json: string) => void;
   loggerFunc: (c: Colonio, log: LogEntry) => void;
 
   constructor() {
+    this.seedSessionTimeoutMs = 30 * 1000;
     this.disableSeedVerification = false;
 
     this.loggerFuncRaw = (c: Colonio, json: string): void => {
@@ -669,7 +671,7 @@ class Colonio {
 
   constructor(config: ColonioConfig) {
     // init
-    this._colonio = ccall("js_init", "number", ["boolean"], [config.disableSeedVerification]);
+    this._colonio = ccall("js_init", "number", ["number", "boolean"], [config.seedSessionTimeoutMs, config.disableSeedVerification]);
     colonioMap.set(this._colonio, this);
 
     // logger
diff --git a/src/js/main.cpp b/src/js/main.cpp
index 352b6775..4997d506 100644
--- a/src/js/main.cpp
+++ b/src/js/main.cpp
@@ -55,7 +55,7 @@ EMSCRIPTEN_KEEPALIVE bool js_error_get_line(PTR_T err);
 EMSCRIPTEN_KEEPALIVE PTR_T js_error_get_file(PTR_T err);
 EMSCRIPTEN_KEEPALIVE int js_error_get_file_length(PTR_T err);
 // colonio
-EMSCRIPTEN_KEEPALIVE COLONIO_T js_init(bool disable_seed_verification);
+EMSCRIPTEN_KEEPALIVE COLONIO_T js_init(unsigned int seed_session_timeout_ms, bool disable_seed_verification);
 EMSCRIPTEN_KEEPALIVE void js_connect(
     COLONIO_T c, PTR_T url, unsigned int url_siz, PTR_T token, unsigned int token_siz, PTR_T on_success,
     PTR_T on_failure);
@@ -204,10 +204,11 @@ int js_error_get_file_length(PTR_T err) {
   return e->file_siz;
 }
 
-COLONIO_T js_init(bool disable_seed_verification) {
+COLONIO_T js_init(unsigned int seed_session_timeout_ms, bool disable_seed_verification) {
   colonio_config_t config;
   colonio_config_set_default(&config);
   config.disable_callback_thread   = true;
+  config.seed_session_timeout_ms   = seed_session_timeout_ms;
   config.disable_seed_verification = disable_seed_verification;
   config.logger_func               = logger_func;
 
diff --git a/test/core/seed_accessor_test.cpp b/test/core/seed_accessor_test.cpp
index 7efb5909..a8dcff3d 100644
--- a/test/core/seed_accessor_test.cpp
+++ b/test/core/seed_accessor_test.cpp
@@ -111,7 +111,8 @@ TEST(SeedAccessorTest, single_node) {
   std::unique_ptr<Scheduler> scheduler(Scheduler::new_instance(logger));
 
   SeedAccessorDelegateStub delegate;
-  SeedAccessor accessor(logger, *scheduler, NodeID::make_random(random), delegate, SEED_URL, std::string(""), 500);
+  SeedAccessor accessor(
+      logger, *scheduler, NodeID::make_random(random), delegate, SEED_URL, std::string(""), 30 * 1000, true);
 
   scheduler->add_task(nullptr, [&]() {
     accessor.enable_polling(true);
@@ -160,11 +161,13 @@ TEST(SeedAccessorTest, relay_poll) {
   std::unique_ptr<Scheduler> scheduler(Scheduler::new_instance(logger));
 
   SeedAccessorDelegateStub delegate1;
-  SeedAccessor accessor1(logger, *scheduler, NodeID::make_random(random), delegate1, SEED_URL, std::string(""), 500);
+  SeedAccessor accessor1(
+      logger, *scheduler, NodeID::make_random(random), delegate1, SEED_URL, std::string(""), 30 * 1000, true);
   accessor1.tell_online_state(true);
 
   SeedAccessorDelegateStub delegate2;
-  SeedAccessor accessor2(logger, *scheduler, NodeID::make_random(random), delegate2, SEED_URL, std::string(""), 500);
+  SeedAccessor accessor2(
+      logger, *scheduler, NodeID::make_random(random), delegate2, SEED_URL, std::string(""), 30 * 1000, true);
   accessor2.tell_online_state(true);
 
   scheduler->add_task(nullptr, [&]() {
@@ -220,7 +223,8 @@ TEST(SeedAccessorTest, detect_error) {
   std::unique_ptr<Scheduler> scheduler(Scheduler::new_instance(logger));
 
   SeedAccessorDelegateStub delegate;
-  SeedAccessor accessor(logger, *scheduler, NodeID::make_random(random), delegate, SEED_URL, std::string(""), 500);
+  SeedAccessor accessor(
+      logger, *scheduler, NodeID::make_random(random), delegate, SEED_URL, std::string(""), 30 * 1000, true);
 
   scheduler->add_task(nullptr, [&]() {
     accessor.enable_polling(true);
diff --git a/test/js/seed.json b/test/js/seed.json
index 5ccd6948..4c543e7a 100644
--- a/test/js/seed.json
+++ b/test/js/seed.json
@@ -1,6 +1,5 @@
 {
-    "revision": 20200401.1,
-    "keepAliveTimeout": 30000,
+    "sessionTimeout": 30000,
     "pollingTimeout": 10000,
     "documentRoot": ".",
     "overrides": {
@@ -16,6 +15,7 @@
     "keyFile": "../../localhost.key",
     "useTcp": true,
     "node": {
+        "revision": 20200401.1,
         "nodeAccessor": {
             "packetSize": 8192,
             "bufferInterval": 200
diff --git a/test/test_utils/test_seed.hpp b/test/test_utils/test_seed.hpp
index ee63bf1e..273ced5d 100644
--- a/test/test_utils/test_seed.hpp
+++ b/test/test_utils/test_seed.hpp
@@ -41,11 +41,11 @@ class TestSeed {
       pid(0),
       path("/test"),
       port(8080),
-      revision(0.1),
-      keep_alive_timeout(30 * 1000),
+      session_timeout(30 * 1000),
       polling_timeout(10 * 1000),
       update_period(500),
-      force_update_times(20) {
+      force_update_times(20),
+      revision(0.1) {
   }
 
   virtual ~TestSeed() {
@@ -137,13 +137,14 @@ class TestSeed {
 
   std::string path;
   int port;
-  double revision;
-  int keep_alive_timeout;
+  int session_timeout;
   int polling_timeout;
 
   int update_period;
   int force_update_times;
 
+  double revision;
+
   picojson::object coord_system;
   picojson::object modules;
 
@@ -158,8 +159,8 @@ class TestSeed {
     picojson::object config;
     config.insert(std::make_pair("path", picojson::value(path)));
     config.insert(std::make_pair("port", picojson::value(static_cast<double>(port))));
-    config.insert(std::make_pair("revision", picojson::value(static_cast<double>(revision))));
-    config.insert(std::make_pair("keepAliveTimeout", picojson::value(static_cast<double>(keep_alive_timeout))));
+    config.insert(std::make_pair("sessionTimeout", picojson::value(static_cast<double>(session_timeout))));
+
     config.insert(std::make_pair("pollingTimeout", picojson::value(static_cast<double>(polling_timeout))));
     config.insert(std::make_pair("useTcp", picojson::value(true)));
 
@@ -186,6 +187,8 @@ class TestSeed {
     routing.insert(std::make_pair("forceUpdateTimes", picojson::value(static_cast<double>(force_update_times))));
 
     picojson::object node;
+    node.insert(std::make_pair("revision", picojson::value(static_cast<double>(revision))));
+
     node.insert(std::make_pair("iceServers", picojson::value(ice_servers)));
     node.insert(std::make_pair("routing", picojson::value(routing)));
     if (!coord_system.empty()) {