diff --git a/.ci/bwcVersions b/.ci/bwcVersions
index ccb47c1a3b724..5587b8e5784c5 100644
--- a/.ci/bwcVersions
+++ b/.ci/bwcVersions
@@ -39,4 +39,5 @@ BWC_VERSION:
   - "2.16.1"
   - "2.17.0"
   - "2.17.1"
+  - "2.17.2"
   - "2.18.0"
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 07637eaae3306..ca23cd59e06d5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -11,13 +11,18 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 - Fallback to Remote cluster-state on Term-Version check mismatch - ([#15424](https://github.com/opensearch-project/OpenSearch/pull/15424))
 - Implement WithFieldName interface in ValuesSourceAggregationBuilder & FieldSortBuilder ([#15916](https://github.com/opensearch-project/OpenSearch/pull/15916))
 - Add successfulSearchShardIndices in searchRequestContext ([#15967](https://github.com/opensearch-project/OpenSearch/pull/15967))
-- Remove identity-related feature flagged code from the RestController ([#15430](https://github.com/opensearch-project/OpenSearch/pull/15430))
 - Add support for msearch API to pass search pipeline name - ([#15923](https://github.com/opensearch-project/OpenSearch/pull/15923))
+- Add _list/indices API as paginated alternate to _cat/indices ([#14718](https://github.com/opensearch-project/OpenSearch/pull/14718))
+- Add success and failure metrics for async shard fetch ([#15976](https://github.com/opensearch-project/OpenSearch/pull/15976))
+- Add new metric REMOTE_STORE to NodeStats API response ([#15611](https://github.com/opensearch-project/OpenSearch/pull/15611))
+- [S3 Repository] Change default retry mechanism of s3 clients to Standard Mode ([#15978](https://github.com/opensearch-project/OpenSearch/pull/15978))
+- Add changes to block calls in cat shards, indices and segments based on dynamic limit settings ([#15986](https://github.com/opensearch-project/OpenSearch/pull/15986))
+- New `phone` & `phone-search` analyzer + tokenizer ([#15915](https://github.com/opensearch-project/OpenSearch/pull/15915))
 
 ### Dependencies
 - Bump `com.azure:azure-identity` from 1.13.0 to 1.13.2 ([#15578](https://github.com/opensearch-project/OpenSearch/pull/15578))
 - Bump `protobuf` from 3.22.3 to 3.25.4 ([#15684](https://github.com/opensearch-project/OpenSearch/pull/15684))
-- Bump `org.apache.logging.log4j:log4j-core` from 2.23.1 to 2.24.0 ([#15858](https://github.com/opensearch-project/OpenSearch/pull/15858))
+- Bump `org.apache.logging.log4j:log4j-core` from 2.23.1 to 2.24.1 ([#15858](https://github.com/opensearch-project/OpenSearch/pull/15858), [#16134](https://github.com/opensearch-project/OpenSearch/pull/16134))
 - Bump `peter-evans/create-pull-request` from 6 to 7 ([#15863](https://github.com/opensearch-project/OpenSearch/pull/15863))
 - Bump `com.nimbusds:oauth2-oidc-sdk` from 11.9.1 to 11.19.1 ([#15862](https://github.com/opensearch-project/OpenSearch/pull/15862))
 - Bump `com.microsoft.azure:msal4j` from 1.17.0 to 1.17.1 ([#15945](https://github.com/opensearch-project/OpenSearch/pull/15945))
@@ -28,9 +33,16 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 - Bump `actions/github-script` from 5 to 7 ([#16039](https://github.com/opensearch-project/OpenSearch/pull/16039))
 - Bump `dnsjava:dnsjava` from 3.6.1 to 3.6.2 ([#16041](https://github.com/opensearch-project/OpenSearch/pull/16041))
 - Bump `com.maxmind.geoip2:geoip2` from 4.2.0 to 4.2.1 ([#16042](https://github.com/opensearch-project/OpenSearch/pull/16042))
+- Bump `com.maxmind.db:maxmind-db` from 3.1.0 to 3.1.1 ([#16137](https://github.com/opensearch-project/OpenSearch/pull/16137))
+- Bump `com.azure:azure-core-http-netty` from 1.15.3 to 1.15.4 ([#16133](https://github.com/opensearch-project/OpenSearch/pull/16133))
+- Bump `org.jline:jline` from 3.26.3 to 3.27.0 ([#16135](https://github.com/opensearch-project/OpenSearch/pull/16135))
+- Bump `netty` from 4.1.112.Final to 4.1.114.Final ([#16182](https://github.com/opensearch-project/OpenSearch/pull/16182))
 
 ### Changed
 - Add support for docker compose v2 in TestFixturesPlugin ([#16049](https://github.com/opensearch-project/OpenSearch/pull/16049))
+- Remove identity-related feature flagged code from the RestController ([#15430](https://github.com/opensearch-project/OpenSearch/pull/15430))
+- Remove Identity FeatureFlag ([#16024](https://github.com/opensearch-project/OpenSearch/pull/16024))
+- Ensure RestHandler.Wrapper delegates all implementations to the wrapped handler ([#16154](https://github.com/opensearch-project/OpenSearch/pull/16154))
 
 
 ### Deprecated
@@ -45,6 +57,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 - Avoid infinite loop when `flat_object` field contains invalid token ([#15985](https://github.com/opensearch-project/OpenSearch/pull/15985))
 - Fix infinite loop in nested agg ([#15931](https://github.com/opensearch-project/OpenSearch/pull/15931))
 - Fix race condition in node-join and node-left ([#15521](https://github.com/opensearch-project/OpenSearch/pull/15521))
+- Streaming bulk request hangs ([#16158](https://github.com/opensearch-project/OpenSearch/pull/16158))
 
 ### Security
 
diff --git a/README.md b/README.md
index 03728aee0135c..95fbac7bbecf1 100644
--- a/README.md
+++ b/README.md
@@ -8,7 +8,7 @@
 [![Open Issues](https://img.shields.io/github/issues/opensearch-project/OpenSearch)](https://github.com/opensearch-project/OpenSearch/issues)
 [![Open Pull Requests](https://img.shields.io/github/issues-pr/opensearch-project/OpenSearch)](https://github.com/opensearch-project/OpenSearch/pulls)
 [![2.18.0 Open Issues](https://img.shields.io/github/issues/opensearch-project/OpenSearch/v2.18.0)](https://github.com/opensearch-project/OpenSearch/issues?q=is%3Aissue+is%3Aopen+label%3A"v2.18.0")
-[![2.17.1 Open Issues](https://img.shields.io/github/issues/opensearch-project/OpenSearch/v2.17.1)](https://github.com/opensearch-project/OpenSearch/issues?q=is%3Aissue+is%3Aopen+label%3A"v2.17.1")
+[![2.17.2 Open Issues](https://img.shields.io/github/issues/opensearch-project/OpenSearch/v2.17.2)](https://github.com/opensearch-project/OpenSearch/issues?q=is%3Aissue+is%3Aopen+label%3A"v2.17.2")
 [![3.0.0 Open Issues](https://img.shields.io/github/issues/opensearch-project/OpenSearch/v3.0.0)](https://github.com/opensearch-project/OpenSearch/issues?q=is%3Aissue+is%3Aopen+label%3A"v3.0.0")
 [![GHA gradle check](https://github.com/opensearch-project/OpenSearch/actions/workflows/gradle-check.yml/badge.svg)](https://github.com/opensearch-project/OpenSearch/actions/workflows/gradle-check.yml)
 [![GHA validate pull request](https://github.com/opensearch-project/OpenSearch/actions/workflows/wrapper.yml/badge.svg)](https://github.com/opensearch-project/OpenSearch/actions/workflows/wrapper.yml)
diff --git a/buildSrc/src/testKit/thirdPartyAudit/sample_jars/build.gradle b/buildSrc/src/testKit/thirdPartyAudit/sample_jars/build.gradle
index 59063b3789c70..4d425964c77af 100644
--- a/buildSrc/src/testKit/thirdPartyAudit/sample_jars/build.gradle
+++ b/buildSrc/src/testKit/thirdPartyAudit/sample_jars/build.gradle
@@ -17,7 +17,7 @@ repositories {
 }
 
 dependencies {
-  implementation "org.apache.logging.log4j:log4j-core:2.24.0"
+  implementation "org.apache.logging.log4j:log4j-core:2.24.1"
 }
 
 ["0.0.1", "0.0.2"].forEach { v ->
diff --git a/buildSrc/version.properties b/buildSrc/version.properties
index 63817289e80c0..8cede6b717883 100644
--- a/buildSrc/version.properties
+++ b/buildSrc/version.properties
@@ -29,7 +29,7 @@ hdrhistogram      = 2.2.2
 # when updating the JNA version, also update the version in buildSrc/build.gradle
 jna               = 5.13.0
 
-netty             = 4.1.112.Final
+netty             = 4.1.114.Final
 joda              = 2.12.7
 
 # project reactor
diff --git a/client/rest-high-level/src/test/java/org/opensearch/client/OpenSearchRestHighLevelClientTestCase.java b/client/rest-high-level/src/test/java/org/opensearch/client/OpenSearchRestHighLevelClientTestCase.java
index b0a7d1e3578c0..b512117c42f65 100644
--- a/client/rest-high-level/src/test/java/org/opensearch/client/OpenSearchRestHighLevelClientTestCase.java
+++ b/client/rest-high-level/src/test/java/org/opensearch/client/OpenSearchRestHighLevelClientTestCase.java
@@ -90,6 +90,7 @@
 public abstract class OpenSearchRestHighLevelClientTestCase extends OpenSearchRestTestCase {
 
     protected static final String CONFLICT_PIPELINE_ID = "conflict_pipeline";
+    protected static final double DOUBLE_DELTA = 0.000001;
 
     private static RestHighLevelClient restHighLevelClient;
     private static boolean async = Booleans.parseBoolean(System.getProperty("tests.rest.async", "false"));
diff --git a/client/rest-high-level/src/test/java/org/opensearch/client/RankEvalIT.java b/client/rest-high-level/src/test/java/org/opensearch/client/RankEvalIT.java
index 01fdd489aa7d8..6da8a29a9789e 100644
--- a/client/rest-high-level/src/test/java/org/opensearch/client/RankEvalIT.java
+++ b/client/rest-high-level/src/test/java/org/opensearch/client/RankEvalIT.java
@@ -158,7 +158,7 @@ public void testMetrics() throws IOException {
 
             RankEvalRequest rankEvalRequest = new RankEvalRequest(spec, new String[] { "index", "index2" });
             RankEvalResponse response = execute(rankEvalRequest, highLevelClient()::rankEval, highLevelClient()::rankEvalAsync);
-            assertEquals(expectedScores[i], response.getMetricScore(), Double.MIN_VALUE);
+            assertEquals(expectedScores[i], response.getMetricScore(), DOUBLE_DELTA);
             i++;
         }
     }
diff --git a/gradle/missing-javadoc.gradle b/gradle/missing-javadoc.gradle
index e9a6d798b8323..26898673bf608 100644
--- a/gradle/missing-javadoc.gradle
+++ b/gradle/missing-javadoc.gradle
@@ -127,6 +127,7 @@ configure([
   project(":plugins:analysis-icu"),
   project(":plugins:analysis-kuromoji"),
   project(":plugins:analysis-nori"),
+  project(":plugins:analysis-phonenumber"),
   project(":plugins:analysis-phonetic"),
   project(":plugins:analysis-smartcn"),
   project(":plugins:analysis-stempel"),
diff --git a/libs/core/src/main/java/org/opensearch/Version.java b/libs/core/src/main/java/org/opensearch/Version.java
index b86b8459fb8a8..5d38f85c40c89 100644
--- a/libs/core/src/main/java/org/opensearch/Version.java
+++ b/libs/core/src/main/java/org/opensearch/Version.java
@@ -110,6 +110,7 @@ public class Version implements Comparable<Version>, ToXContentFragment {
     public static final Version V_2_16_1 = new Version(2160199, org.apache.lucene.util.Version.LUCENE_9_11_1);
     public static final Version V_2_17_0 = new Version(2170099, org.apache.lucene.util.Version.LUCENE_9_11_1);
     public static final Version V_2_17_1 = new Version(2170199, org.apache.lucene.util.Version.LUCENE_9_11_1);
+    public static final Version V_2_17_2 = new Version(2170299, org.apache.lucene.util.Version.LUCENE_9_11_1);
     public static final Version V_2_18_0 = new Version(2180099, org.apache.lucene.util.Version.LUCENE_9_11_1);
     public static final Version V_3_0_0 = new Version(3000099, org.apache.lucene.util.Version.LUCENE_9_12_0);
     public static final Version CURRENT = V_3_0_0;
diff --git a/libs/core/src/main/java/org/opensearch/core/common/Strings.java b/libs/core/src/main/java/org/opensearch/core/common/Strings.java
index 8fdec670bd9f2..e8379e11ea26a 100644
--- a/libs/core/src/main/java/org/opensearch/core/common/Strings.java
+++ b/libs/core/src/main/java/org/opensearch/core/common/Strings.java
@@ -815,4 +815,17 @@ public static String toLowercaseAscii(String in) {
         }
         return out.toString();
     }
+
+    /**
+     * Check whether every single character in the string is a digit.
+     *
+     * <p>An empty string returns {@code false}.</p>
+     *
+     * @param s the string, must not be null.
+     * @return {@code true} if the string only contains digits, {@code false} otherwise.
+     */
+    public static boolean isDigits(final String s) {
+        return !s.isEmpty() && s.chars().allMatch(Character::isDigit);
+    }
+
 }
diff --git a/libs/core/src/test/java/org/opensearch/core/common/StringsTests.java b/libs/core/src/test/java/org/opensearch/core/common/StringsTests.java
index b79bb6fc89f9e..be7af18b106a8 100644
--- a/libs/core/src/test/java/org/opensearch/core/common/StringsTests.java
+++ b/libs/core/src/test/java/org/opensearch/core/common/StringsTests.java
@@ -114,4 +114,15 @@ public void testToStringToXContentWithOrWithoutParams() {
             containsString("\"color_from_param\":\"blue\"")
         );
     }
+
+    public void testIsDigits() {
+        assertTrue(Strings.isDigits("1"));
+        assertTrue(Strings.isDigits("123"));
+        assertFalse(Strings.isDigits(""));
+        assertFalse(Strings.isDigits("abc"));
+        assertFalse(Strings.isDigits("123a"));
+        assertFalse(Strings.isDigits("0x123"));
+        assertFalse(Strings.isDigits("123.4"));
+        assertFalse(Strings.isDigits("123f"));
+    }
 }
diff --git a/modules/ingest-geoip/build.gradle b/modules/ingest-geoip/build.gradle
index 162ac6f9ad620..f74de1dc290dd 100644
--- a/modules/ingest-geoip/build.gradle
+++ b/modules/ingest-geoip/build.gradle
@@ -41,7 +41,7 @@ opensearchplugin {
 dependencies {
   api('com.maxmind.geoip2:geoip2:4.2.1')
   // geoip2 dependencies:
-  api('com.maxmind.db:maxmind-db:3.1.0')
+  api('com.maxmind.db:maxmind-db:3.1.1')
   api("com.fasterxml.jackson.core:jackson-annotations:${versions.jackson}")
   api("com.fasterxml.jackson.core:jackson-databind:${versions.jackson_databind}")
 
diff --git a/modules/ingest-geoip/licenses/maxmind-db-3.1.0.jar.sha1 b/modules/ingest-geoip/licenses/maxmind-db-3.1.0.jar.sha1
deleted file mode 100644
index 9db7c7319af0b..0000000000000
--- a/modules/ingest-geoip/licenses/maxmind-db-3.1.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-2008992ab45d61c7b28a18678b5df82272529da3
\ No newline at end of file
diff --git a/modules/ingest-geoip/licenses/maxmind-db-3.1.1.jar.sha1 b/modules/ingest-geoip/licenses/maxmind-db-3.1.1.jar.sha1
new file mode 100644
index 0000000000000..f1a25c6d600c0
--- /dev/null
+++ b/modules/ingest-geoip/licenses/maxmind-db-3.1.1.jar.sha1
@@ -0,0 +1 @@
+84a2a5d322fef1f1e82f05095683c8d53902baf1
\ No newline at end of file
diff --git a/modules/transport-netty4/licenses/netty-buffer-4.1.112.Final.jar.sha1 b/modules/transport-netty4/licenses/netty-buffer-4.1.112.Final.jar.sha1
deleted file mode 100644
index 5c26883046fed..0000000000000
--- a/modules/transport-netty4/licenses/netty-buffer-4.1.112.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-bdc12df04bb6858890b8aa108060b5b365a26102
\ No newline at end of file
diff --git a/modules/transport-netty4/licenses/netty-buffer-4.1.114.Final.jar.sha1 b/modules/transport-netty4/licenses/netty-buffer-4.1.114.Final.jar.sha1
new file mode 100644
index 0000000000000..8cb83fc367d78
--- /dev/null
+++ b/modules/transport-netty4/licenses/netty-buffer-4.1.114.Final.jar.sha1
@@ -0,0 +1 @@
+f1d77d15c0b781cd9395a2a956262766fd0c7602
\ No newline at end of file
diff --git a/modules/transport-netty4/licenses/netty-codec-4.1.112.Final.jar.sha1 b/modules/transport-netty4/licenses/netty-codec-4.1.112.Final.jar.sha1
deleted file mode 100644
index 1fd224fdd0b44..0000000000000
--- a/modules/transport-netty4/licenses/netty-codec-4.1.112.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-c87f2ec3d9a97bd2b793d16817abb2bab93a7fc3
\ No newline at end of file
diff --git a/modules/transport-netty4/licenses/netty-codec-4.1.114.Final.jar.sha1 b/modules/transport-netty4/licenses/netty-codec-4.1.114.Final.jar.sha1
new file mode 100644
index 0000000000000..1be26fee34d46
--- /dev/null
+++ b/modules/transport-netty4/licenses/netty-codec-4.1.114.Final.jar.sha1
@@ -0,0 +1 @@
+5a49dfa2828d64bf756f670e63259115332744cf
\ No newline at end of file
diff --git a/modules/transport-netty4/licenses/netty-codec-http-4.1.112.Final.jar.sha1 b/modules/transport-netty4/licenses/netty-codec-http-4.1.112.Final.jar.sha1
deleted file mode 100644
index 22d35128c3ad5..0000000000000
--- a/modules/transport-netty4/licenses/netty-codec-http-4.1.112.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-81af1040bfa977f98dd0e1bd9639513ea862ca04
\ No newline at end of file
diff --git a/modules/transport-netty4/licenses/netty-codec-http-4.1.114.Final.jar.sha1 b/modules/transport-netty4/licenses/netty-codec-http-4.1.114.Final.jar.sha1
new file mode 100644
index 0000000000000..e683773245716
--- /dev/null
+++ b/modules/transport-netty4/licenses/netty-codec-http-4.1.114.Final.jar.sha1
@@ -0,0 +1 @@
+fbce5a53884275662e68aaad70f88bf7e5d04164
\ No newline at end of file
diff --git a/modules/transport-netty4/licenses/netty-codec-http2-4.1.112.Final.jar.sha1 b/modules/transport-netty4/licenses/netty-codec-http2-4.1.112.Final.jar.sha1
deleted file mode 100644
index d4767d06b22bf..0000000000000
--- a/modules/transport-netty4/licenses/netty-codec-http2-4.1.112.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-7fa28b510f0f16f4d5d7188b86bef59e048f62f9
\ No newline at end of file
diff --git a/modules/transport-netty4/licenses/netty-codec-http2-4.1.114.Final.jar.sha1 b/modules/transport-netty4/licenses/netty-codec-http2-4.1.114.Final.jar.sha1
new file mode 100644
index 0000000000000..2c18924e33c62
--- /dev/null
+++ b/modules/transport-netty4/licenses/netty-codec-http2-4.1.114.Final.jar.sha1
@@ -0,0 +1 @@
+19ae07fdf99142a70338f8cda70a3d2edbc8e80a
\ No newline at end of file
diff --git a/modules/transport-netty4/licenses/netty-common-4.1.112.Final.jar.sha1 b/modules/transport-netty4/licenses/netty-common-4.1.112.Final.jar.sha1
deleted file mode 100644
index 47af3100f0f2d..0000000000000
--- a/modules/transport-netty4/licenses/netty-common-4.1.112.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-b2798069092a981a832b7510d0462ee9efb7a80e
\ No newline at end of file
diff --git a/modules/transport-netty4/licenses/netty-common-4.1.114.Final.jar.sha1 b/modules/transport-netty4/licenses/netty-common-4.1.114.Final.jar.sha1
new file mode 100644
index 0000000000000..74ce939dc6190
--- /dev/null
+++ b/modules/transport-netty4/licenses/netty-common-4.1.114.Final.jar.sha1
@@ -0,0 +1 @@
+862712e292b162c8ccaa7847a6a54df8178f77e5
\ No newline at end of file
diff --git a/modules/transport-netty4/licenses/netty-handler-4.1.112.Final.jar.sha1 b/modules/transport-netty4/licenses/netty-handler-4.1.112.Final.jar.sha1
deleted file mode 100644
index 8b30272861770..0000000000000
--- a/modules/transport-netty4/licenses/netty-handler-4.1.112.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-3d5e2d5bcc6baeeb8c13a230980c6132a778e036
\ No newline at end of file
diff --git a/modules/transport-netty4/licenses/netty-handler-4.1.114.Final.jar.sha1 b/modules/transport-netty4/licenses/netty-handler-4.1.114.Final.jar.sha1
new file mode 100644
index 0000000000000..c431976b6fbd2
--- /dev/null
+++ b/modules/transport-netty4/licenses/netty-handler-4.1.114.Final.jar.sha1
@@ -0,0 +1 @@
+e56fbde4b9aa628eed15a5dbfbeb97877db88146
\ No newline at end of file
diff --git a/modules/transport-netty4/licenses/netty-resolver-4.1.112.Final.jar.sha1 b/modules/transport-netty4/licenses/netty-resolver-4.1.112.Final.jar.sha1
deleted file mode 100644
index 1a094fa19a623..0000000000000
--- a/modules/transport-netty4/licenses/netty-resolver-4.1.112.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-58a631d9d44c4ed7cc0dcc9cffa6641da9374d72
\ No newline at end of file
diff --git a/modules/transport-netty4/licenses/netty-resolver-4.1.114.Final.jar.sha1 b/modules/transport-netty4/licenses/netty-resolver-4.1.114.Final.jar.sha1
new file mode 100644
index 0000000000000..e8080a5b2acb1
--- /dev/null
+++ b/modules/transport-netty4/licenses/netty-resolver-4.1.114.Final.jar.sha1
@@ -0,0 +1 @@
+10b23784b23d6a948930f52ba82874f1291b5873
\ No newline at end of file
diff --git a/modules/transport-netty4/licenses/netty-transport-4.1.112.Final.jar.sha1 b/modules/transport-netty4/licenses/netty-transport-4.1.112.Final.jar.sha1
deleted file mode 100644
index 5fbfde0836e0c..0000000000000
--- a/modules/transport-netty4/licenses/netty-transport-4.1.112.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-77cd136dd3843f5e7cbcf68c824975d745c49ddb
\ No newline at end of file
diff --git a/modules/transport-netty4/licenses/netty-transport-4.1.114.Final.jar.sha1 b/modules/transport-netty4/licenses/netty-transport-4.1.114.Final.jar.sha1
new file mode 100644
index 0000000000000..fb2d518789a18
--- /dev/null
+++ b/modules/transport-netty4/licenses/netty-transport-4.1.114.Final.jar.sha1
@@ -0,0 +1 @@
+e0225a575f487904be8517092cbd74e01913533c
\ No newline at end of file
diff --git a/modules/transport-netty4/licenses/netty-transport-native-unix-common-4.1.112.Final.jar.sha1 b/modules/transport-netty4/licenses/netty-transport-native-unix-common-4.1.112.Final.jar.sha1
deleted file mode 100644
index 8dad0e3104dc8..0000000000000
--- a/modules/transport-netty4/licenses/netty-transport-native-unix-common-4.1.112.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-b50ff619cdcdc48e748cba3405c9988529f28f60
\ No newline at end of file
diff --git a/modules/transport-netty4/licenses/netty-transport-native-unix-common-4.1.114.Final.jar.sha1 b/modules/transport-netty4/licenses/netty-transport-native-unix-common-4.1.114.Final.jar.sha1
new file mode 100644
index 0000000000000..a80b9e51be74b
--- /dev/null
+++ b/modules/transport-netty4/licenses/netty-transport-native-unix-common-4.1.114.Final.jar.sha1
@@ -0,0 +1 @@
+d1171bb99411f282068f49d780cedf8c9adeabfd
\ No newline at end of file
diff --git a/plugins/analysis-phonenumber/build.gradle b/plugins/analysis-phonenumber/build.gradle
new file mode 100644
index 0000000000000..c9913b36f8508
--- /dev/null
+++ b/plugins/analysis-phonenumber/build.gradle
@@ -0,0 +1,21 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ *
+ * Modifications Copyright OpenSearch Contributors. See
+ * GitHub history for details.
+ */
+
+apply plugin: 'opensearch.yaml-rest-test'
+
+opensearchplugin {
+  description 'Adds an analyzer for phone numbers to OpenSearch.'
+  classname 'org.opensearch.analysis.phone.PhoneNumberAnalysisPlugin'
+}
+
+dependencies {
+  implementation group: 'com.googlecode.libphonenumber', name: 'libphonenumber', version: '8.13.45'
+}
diff --git a/plugins/analysis-phonenumber/licenses/libphonenumber-8.13.45.jar.sha1 b/plugins/analysis-phonenumber/licenses/libphonenumber-8.13.45.jar.sha1
new file mode 100644
index 0000000000000..00d393482ee49
--- /dev/null
+++ b/plugins/analysis-phonenumber/licenses/libphonenumber-8.13.45.jar.sha1
@@ -0,0 +1 @@
+bfac00f71616796abc7d8b135dda12558a0ccee2
\ No newline at end of file
diff --git a/plugins/analysis-phonenumber/licenses/libphonenumber-LICENSE.txt b/plugins/analysis-phonenumber/licenses/libphonenumber-LICENSE.txt
new file mode 100644
index 0000000000000..d9a10c0d8e868
--- /dev/null
+++ b/plugins/analysis-phonenumber/licenses/libphonenumber-LICENSE.txt
@@ -0,0 +1,176 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
diff --git a/plugins/analysis-phonenumber/licenses/libphonenumber-NOTICE.txt b/plugins/analysis-phonenumber/licenses/libphonenumber-NOTICE.txt
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/plugins/analysis-phonenumber/src/main/java/org/opensearch/analysis/phone/PhoneNumberAnalysisPlugin.java b/plugins/analysis-phonenumber/src/main/java/org/opensearch/analysis/phone/PhoneNumberAnalysisPlugin.java
new file mode 100644
index 0000000000000..eb12b43f70154
--- /dev/null
+++ b/plugins/analysis-phonenumber/src/main/java/org/opensearch/analysis/phone/PhoneNumberAnalysisPlugin.java
@@ -0,0 +1,60 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.analysis.phone;
+
+import org.apache.lucene.analysis.Analyzer;
+import org.opensearch.index.analysis.AnalyzerProvider;
+import org.opensearch.index.analysis.TokenizerFactory;
+import org.opensearch.indices.analysis.AnalysisModule;
+import org.opensearch.plugins.AnalysisPlugin;
+import org.opensearch.plugins.Plugin;
+
+import java.util.Map;
+import java.util.TreeMap;
+
+/**
+ * This plugin provides an analyzer and tokenizer for fields which contain phone numbers, supporting a variety of formats
+ * (with/without international calling code, different country formats, etc.).
+ */
+public class PhoneNumberAnalysisPlugin extends Plugin implements AnalysisPlugin {
+
+    @Override
+    public Map<String, AnalysisModule.AnalysisProvider<AnalyzerProvider<? extends Analyzer>>> getAnalyzers() {
+        Map<String, AnalysisModule.AnalysisProvider<AnalyzerProvider<? extends Analyzer>>> analyzers = new TreeMap<>();
+        analyzers.put(
+            "phone",
+            (indexSettings, environment, name, settings) -> new PhoneNumberAnalyzerProvider(indexSettings, "phone", settings, true)
+        );
+        analyzers.put(
+            "phone-search",
+            (indexSettings, environment, name, settings) -> new PhoneNumberAnalyzerProvider(indexSettings, "phone-search", settings, false)
+        );
+        return analyzers;
+    }
+
+    @Override
+    public Map<String, AnalysisModule.AnalysisProvider<TokenizerFactory>> getTokenizers() {
+        Map<String, AnalysisModule.AnalysisProvider<TokenizerFactory>> tokenizers = new TreeMap<>();
+        tokenizers.put(
+            "phone",
+            (indexSettings, environment, name, settings) -> new PhoneNumberTermTokenizerFactory(indexSettings, "phone", settings, true)
+        );
+        tokenizers.put(
+            "phone-search",
+            (indexSettings, environment, name, settings) -> new PhoneNumberTermTokenizerFactory(
+                indexSettings,
+                "phone-search",
+                settings,
+                false
+            )
+        );
+        return tokenizers;
+    }
+
+}
diff --git a/plugins/analysis-phonenumber/src/main/java/org/opensearch/analysis/phone/PhoneNumberAnalyzer.java b/plugins/analysis-phonenumber/src/main/java/org/opensearch/analysis/phone/PhoneNumberAnalyzer.java
new file mode 100644
index 0000000000000..cd945e186b2ba
--- /dev/null
+++ b/plugins/analysis-phonenumber/src/main/java/org/opensearch/analysis/phone/PhoneNumberAnalyzer.java
@@ -0,0 +1,51 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.analysis.phone;
+
+import org.apache.lucene.analysis.Analyzer;
+import org.opensearch.common.settings.Settings;
+
+/**
+ * Analyzer for phone numbers, using {@link PhoneNumberTermTokenizer}.
+ *
+ * <p>
+ * You can use the {@code phone} and {@code phone-search} analyzers on your fields to index phone numbers.
+ * Use {@code phone} (which creates ngrams) for the {@code analyzer} and {@code phone-search} (which doesn't create ngrams)
+ * for the {@code search_analyzer}.
+ * </p>
+ *
+ * <p>
+ * You optionally can specify a region with the {@code phone-region} setting for the phone number which will ensure that
+ * phone numbers without the international  dialling prefix (using {@code +}) are also tokenized correctly.
+ * </p>
+ *
+ * <p>
+ * Note that the tokens will not refer to a specific position in the stream as the tokenizer is expected to be used on strings
+ * containing phone numbers and not arbitrary text with interspersed phone numbers.
+ * </p>
+ */
+public class PhoneNumberAnalyzer extends Analyzer {
+    private final boolean addNgrams;
+    private final Settings settings;
+
+    /**
+     * @param addNgrams defines whether ngrams for the phone number should be added. Set to true for indexing and false for search.
+     * @param settings the settings for the analyzer.
+     */
+    public PhoneNumberAnalyzer(final Settings settings, final boolean addNgrams) {
+        this.addNgrams = addNgrams;
+        this.settings = settings;
+    }
+
+    @Override
+    protected TokenStreamComponents createComponents(String fieldName) {
+        final var tokenizer = new PhoneNumberTermTokenizer(this.settings, this.addNgrams);
+        return new Analyzer.TokenStreamComponents(tokenizer, tokenizer);
+    }
+}
diff --git a/plugins/analysis-phonenumber/src/main/java/org/opensearch/analysis/phone/PhoneNumberAnalyzerProvider.java b/plugins/analysis-phonenumber/src/main/java/org/opensearch/analysis/phone/PhoneNumberAnalyzerProvider.java
new file mode 100644
index 0000000000000..272a019ba0f9c
--- /dev/null
+++ b/plugins/analysis-phonenumber/src/main/java/org/opensearch/analysis/phone/PhoneNumberAnalyzerProvider.java
@@ -0,0 +1,42 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.analysis.phone;
+
+import org.opensearch.common.settings.Settings;
+import org.opensearch.index.IndexSettings;
+import org.opensearch.index.analysis.AbstractIndexAnalyzerProvider;
+
+/**
+ * Provider for {@link PhoneNumberAnalyzer}.
+ */
+public class PhoneNumberAnalyzerProvider extends AbstractIndexAnalyzerProvider<PhoneNumberAnalyzer> {
+
+    private final PhoneNumberAnalyzer analyzer;
+
+    /**
+     * @param indexSettings the settings of the index.
+     * @param name the analyzer name.
+     * @param settings the settings for the analyzer.
+     * @param addNgrams defines whether ngrams for the phone number should be added. Set to true for indexing and false for search.
+     */
+    public PhoneNumberAnalyzerProvider(
+        final IndexSettings indexSettings,
+        final String name,
+        final Settings settings,
+        final boolean addNgrams
+    ) {
+        super(indexSettings, name, settings);
+        this.analyzer = new PhoneNumberAnalyzer(settings, addNgrams);
+    }
+
+    @Override
+    public PhoneNumberAnalyzer get() {
+        return this.analyzer;
+    }
+}
diff --git a/plugins/analysis-phonenumber/src/main/java/org/opensearch/analysis/phone/PhoneNumberTermTokenizer.java b/plugins/analysis-phonenumber/src/main/java/org/opensearch/analysis/phone/PhoneNumberTermTokenizer.java
new file mode 100644
index 0000000000000..6b95594204eb4
--- /dev/null
+++ b/plugins/analysis-phonenumber/src/main/java/org/opensearch/analysis/phone/PhoneNumberTermTokenizer.java
@@ -0,0 +1,157 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.analysis.phone;
+
+import com.google.i18n.phonenumbers.NumberParseException;
+import com.google.i18n.phonenumbers.PhoneNumberUtil;
+import org.apache.lucene.analysis.Tokenizer;
+import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;
+import org.opensearch.common.io.Streams;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.core.common.Strings;
+
+import java.io.IOException;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Optional;
+import java.util.Set;
+
+/**
+ * This tokenizes a phone number into its individual parts, using {@link PhoneNumberUtil}.
+ *
+ * <p>
+ * You can use the {@code phone} and {@code phone-search} analyzers on your fields to index phone numbers.
+ * Use {@code phone} (which creates ngrams) for the {@code analyzer} and {@code phone-search} (which doesn't create ngrams)
+ * for the {@code search_analyzer}.
+ * </p>
+ *
+ * <p>
+ * You optionally can specify a region with the {@code phone-region} setting for the phone number which will ensure that
+ * phone numbers without the international  dialling prefix (using {@code +}) are also tokenized correctly.
+ * </p>
+ *
+ * <p>
+ * Note that the tokens will not refer to a specific position in the stream as the tokenizer is expected to be used on strings
+ * containing phone numbers and not arbitrary text with interspersed phone numbers.
+ * </p>
+ */
+public final class PhoneNumberTermTokenizer extends Tokenizer {
+    private final boolean addNgrams;
+    private final Settings settings;
+    private final CharTermAttribute termAtt = addAttribute(CharTermAttribute.class);
+    private Iterator<String> tokenIterator;
+
+    /**
+     * @param addNgrams defines whether ngrams for the phone number should be added. Set to true for indexing and false for search.
+     * @param settings the settings for the analyzer.
+     */
+    public PhoneNumberTermTokenizer(final Settings settings, final boolean addNgrams) {
+        super();
+        this.addNgrams = addNgrams;
+        this.settings = settings;
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public void reset() throws IOException {
+        super.reset();
+        tokenIterator = null;
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public boolean incrementToken() throws IOException {
+        clearAttributes();
+        if (tokenIterator == null) {
+            tokenIterator = getTokens().iterator();
+        }
+        if (tokenIterator.hasNext()) {
+            termAtt.append(tokenIterator.next());
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Search for a phone number in the input and tokenize it.
+     *
+     * <p>
+     * The tokens include the full phone number with and without country prefix (if it could be identified) and - if
+     * enabled by {@link #addNgrams} - an ngram of the phone number.
+     * </p>
+     *
+     * @return all tokens (unique, unordered).
+     * @throws IOException in case the input cannot be read.
+     */
+    private Set<String> getTokens() throws IOException {
+        final var tokens = new HashSet<String>();
+
+        var input = Streams.copyToString(this.input);
+
+        tokens.add(input);
+
+        // Rip off the "tel:" or "sip:" prefix
+        if (input.indexOf("tel:") == 0 || input.indexOf("sip:") == 0) {
+            tokens.add(input.substring(0, 4));
+            input = input.substring(4);
+        }
+
+        final var startIndex = input.startsWith("+") ? 1 : 0;
+        // Add the complete input but skip a leading +
+        tokens.add(input.substring(startIndex));
+
+        // Drop anything after @. Most likely there's nothing of interest
+        final var posAt = input.indexOf('@');
+        if (posAt != -1) {
+            input = input.substring(0, posAt);
+
+            // Add a token for the raw unmanipulated address. Note this could be a username (sip) instead of telephone
+            // number so take it as is
+            tokens.add(input.substring(startIndex));
+        }
+
+        // Let google's libphone try to parse it
+        final var phoneUtil = PhoneNumberUtil.getInstance();
+        Optional<String> countryCode = Optional.empty();
+        try {
+            // ZZ is the generic "I don't know the country code" region. Google's libphone library will try to infer it.
+            final var region = this.settings.get("phone-region", "ZZ");
+            final var numberProto = phoneUtil.parse(input, region);
+            if (numberProto != null) {
+                // Libphone likes it!
+                countryCode = Optional.of(String.valueOf(numberProto.getCountryCode()));
+                input = String.valueOf(numberProto.getNationalNumber());
+
+                // Add Country code, extension, and the number as tokens
+                tokens.add(countryCode.get());
+                tokens.add(countryCode.get() + input);
+                if (!Strings.isEmpty(numberProto.getExtension())) {
+                    tokens.add(numberProto.getExtension());
+                }
+
+                tokens.add(input);
+            }
+        } catch (final NumberParseException | StringIndexOutOfBoundsException e) {
+            // Libphone didn't like it, no biggie. We'll just ngram the number as it is.
+        }
+
+        // ngram the phone number, e.g. 19198243333 produces 9, 91, 919, etc
+        if (this.addNgrams && Strings.isDigits(input)) {
+            for (int count = 1; count <= input.length(); ++count) {
+                final var token = input.substring(0, count);
+                tokens.add(token);
+                // If there was a country code, add more ngrams such that 19198243333 produces 19, 191, 1919, etc
+                countryCode.ifPresent(s -> tokens.add(s + token));
+            }
+        }
+
+        return tokens;
+    }
+
+}
diff --git a/plugins/analysis-phonenumber/src/main/java/org/opensearch/analysis/phone/PhoneNumberTermTokenizerFactory.java b/plugins/analysis-phonenumber/src/main/java/org/opensearch/analysis/phone/PhoneNumberTermTokenizerFactory.java
new file mode 100644
index 0000000000000..fde44e15c9667
--- /dev/null
+++ b/plugins/analysis-phonenumber/src/main/java/org/opensearch/analysis/phone/PhoneNumberTermTokenizerFactory.java
@@ -0,0 +1,44 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.analysis.phone;
+
+import org.apache.lucene.analysis.Tokenizer;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.index.IndexSettings;
+import org.opensearch.index.analysis.AbstractTokenizerFactory;
+
+/**
+ * Factory for {@link PhoneNumberTermTokenizer}.
+ */
+public class PhoneNumberTermTokenizerFactory extends AbstractTokenizerFactory {
+    private final Settings settings;
+    private final boolean addNgrams;
+
+    /**
+     * @param indexSettings the settings of the index.
+     * @param name the tokenizer name.
+     * @param settings the settings for the analyzer.
+     * @param addNgrams defines whether ngrams for the phone number should be added. Set to true for indexing and false for search.
+     */
+    public PhoneNumberTermTokenizerFactory(
+        final IndexSettings indexSettings,
+        final String name,
+        final Settings settings,
+        final boolean addNgrams
+    ) {
+        super(indexSettings, settings, name);
+        this.settings = settings;
+        this.addNgrams = addNgrams;
+    }
+
+    @Override
+    public Tokenizer create() {
+        return new PhoneNumberTermTokenizer(this.settings, this.addNgrams);
+    }
+}
diff --git a/plugins/analysis-phonenumber/src/test/java/org/opensearch/analysis/phone/PhoneNumberAnalyzerTests.java b/plugins/analysis-phonenumber/src/test/java/org/opensearch/analysis/phone/PhoneNumberAnalyzerTests.java
new file mode 100644
index 0000000000000..332f6d21f47d6
--- /dev/null
+++ b/plugins/analysis-phonenumber/src/test/java/org/opensearch/analysis/phone/PhoneNumberAnalyzerTests.java
@@ -0,0 +1,253 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.analysis.phone;
+
+import org.apache.lucene.analysis.Analyzer;
+import org.apache.lucene.analysis.TokenStream;
+import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;
+import org.opensearch.index.analysis.AnalysisTestsHelper;
+import org.opensearch.test.OpenSearchTokenStreamTestCase;
+import org.junit.BeforeClass;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import static org.hamcrest.Matchers.arrayContainingInAnyOrder;
+import static org.hamcrest.Matchers.hasItemInArray;
+
+public class PhoneNumberAnalyzerTests extends OpenSearchTokenStreamTestCase {
+    private static final String RESOURCE = "/org/opensearch/analysis/phone/phone_analysis.json";
+
+    private static Analyzer phoneAnalyzer;
+    private static Analyzer phoneSearchAnalyzer;
+    private static Analyzer phoneCHAnalyzer;
+    private static Analyzer phoneSearchCHAnalyzer;
+
+    @BeforeClass
+    public static void beforeClass() throws IOException {
+        final var analysis = AnalysisTestsHelper.createTestAnalysisFromClassPath(
+            createTempDir(),
+            RESOURCE,
+            new PhoneNumberAnalysisPlugin()
+        );
+        phoneAnalyzer = analysis.indexAnalyzers.get("phone");
+        assertNotNull(phoneAnalyzer);
+        phoneSearchAnalyzer = analysis.indexAnalyzers.get("phone-search");
+        assertNotNull(phoneSearchAnalyzer);
+        phoneCHAnalyzer = analysis.indexAnalyzers.get("phone-ch");
+        assertNotNull(phoneCHAnalyzer);
+        phoneSearchCHAnalyzer = analysis.indexAnalyzers.get("phone-search-ch");
+        assertNotNull(phoneSearchCHAnalyzer);
+    }
+
+    /**
+     * Test for all tokens which are emitted by the "phone" analyzer.
+     */
+    public void testEuropeDetailled() throws IOException {
+        assertTokensAreInAnyOrder(
+            phoneAnalyzer,
+            "tel:+441344840400",
+            Arrays.asList(
+                "tel:+441344840400",
+                "tel:",
+                "441344840400",
+                "44",
+                "1344840400",
+                "1",
+                "441",
+                "13",
+                "4413",
+                "134",
+                "44134",
+                "1344",
+                "441344",
+                "13448",
+                "4413448",
+                "134484",
+                "44134484",
+                "1344840",
+                "441344840",
+                "13448404",
+                "4413448404",
+                "134484040",
+                "44134484040"
+            )
+        );
+    }
+
+    /**
+     * Test for all tokens which are emitted by the "phone" analyzer.
+     */
+    public void testEuropeDetailledSearch() throws IOException {
+        assertTokensAreInAnyOrder(
+            phoneSearchAnalyzer,
+            "tel:+441344840400",
+            Arrays.asList("tel:+441344840400", "tel:", "441344840400", "44", "1344840400")
+        );
+    }
+
+    public void testEurope() throws IOException {
+        assertTokensInclude("tel:+441344840400", Arrays.asList("44", "1344", "1344840400", "441344840400"));
+    }
+
+    public void testGermanCastle() throws IOException {
+        assertTokensInclude("tel:+498362930830", Arrays.asList("49", "498362930830", "8362930830"));
+    }
+
+    public void testBMWofSydney() throws IOException {
+        assertTokensInclude("tel:+61293344555", Arrays.asList("61", "293344555", "61293344555"));
+    }
+
+    public void testCoffeeShopInIreland() throws IOException {
+        assertTokensInclude("tel:+442890319416", Arrays.asList("44", "289", "2890319416", "442890319416"));
+    }
+
+    public void testTelWithCountryCode() throws IOException {
+        assertTokensInclude("tel:+17177158163", Arrays.asList("1", "717", "7177", "17177158163"));
+    }
+
+    public void testTelWithCountryCode2() throws IOException {
+        assertTokensInclude("tel:+12177148350", Arrays.asList("1", "217", "2177", "2177148350", "12177148350"));
+    }
+
+    public void testNewTollFreeNumber() throws IOException {
+        assertTokensInclude("tel:+18337148350", Arrays.asList("1", "833", "8337", "8337148350", "18337148350"));
+    }
+
+    public void testMissingCountryCode() throws IOException {
+        assertTokensInclude("tel:8177148350", Arrays.asList("817", "8177", "81771", "817714", "8177148350"));
+    }
+
+    public void testSipWithNumericUsername() throws IOException {
+        assertTokensInclude("sip:222@autosbcpc", Arrays.asList("222"));
+    }
+
+    public void testTruncatedNumber() throws IOException {
+        assertTokensInclude("tel:5551234", Arrays.asList("5551234"));
+    }
+
+    public void testSipWithAlphabeticUsername() throws IOException {
+        assertTokensInclude("sip:abc@autosbcpc", Arrays.asList("abc"));
+    }
+
+    public void testGarbageInGarbageOut() throws IOException {
+        assertTokensInclude("test", Arrays.asList("test"));
+    }
+
+    public void testSipWithCountryCode() throws IOException {
+        assertTokensInclude("sip:+14177141363@178.97.105.13;isup-oli=0;pstn-params=808481808882", Arrays.asList("417", "4177", "14177"));
+    }
+
+    public void testSipWithTelephoneExtension() throws IOException {
+        assertTokensInclude("sip:+13169410766;ext=2233@178.17.10.117:8060", Arrays.asList("316", "2233", "1316"));
+    }
+
+    public void testSipWithUsername() throws IOException {
+        assertTokensInclude("sip:JeffSIP@178.12.220.18", Arrays.asList("JeffSIP"));
+    }
+
+    public void testPhoneNumberWithoutPrefix() throws IOException {
+        assertTokensInclude("+14177141363", Arrays.asList("14177141363", "417", "4177", "14177"));
+    }
+
+    public void testSipWithoutDomainPart() throws IOException {
+        assertTokensInclude("sip:+122882", Arrays.asList("122882", "122", "228", "1228", "2288", "12288"));
+    }
+
+    public void testTelPrefix() throws IOException {
+        assertTokensInclude("tel:+1228", Arrays.asList("1228", "122", "228"));
+    }
+
+    public void testNumberPrefix() throws IOException {
+        assertTokensInclude("+1228", Arrays.asList("1228", "122", "228"));
+    }
+
+    public void testInternationalPrefixWithZZ() throws IOException {
+        assertTokensInclude(phoneAnalyzer, "+41583161010", Arrays.asList("41", "41583161010", "583161010"));
+    }
+
+    public void testInternationalPrefixWithCH() throws IOException {
+        assertTokensInclude(phoneCHAnalyzer, "+41583161010", Arrays.asList("41", "41583161010", "583161010"));
+    }
+
+    public void testNationalPrefixWithCH() throws IOException {
+        // + is equivalent to 00 in Switzerland
+        assertTokensInclude(phoneCHAnalyzer, "0041583161010", Arrays.asList("41", "41583161010", "583161010"));
+    }
+
+    public void testLocalNumberWithCH() throws IOException {
+        // when omitting the international prefix swiss numbers must start with '0'
+        assertTokensInclude(phoneCHAnalyzer, "0583161010", Arrays.asList("41", "41583161010", "583161010"));
+    }
+
+    public void testSearchInternationalPrefixWithZZ() throws IOException {
+        assertTokensInclude(phoneSearchAnalyzer, "+41583161010", Arrays.asList("41", "41583161010", "583161010"));
+    }
+
+    public void testSearchInternationalPrefixWithCH() throws IOException {
+        assertTokensInclude(phoneSearchCHAnalyzer, "+41583161010", Arrays.asList("41", "41583161010", "583161010"));
+    }
+
+    public void testSearchNationalPrefixWithCH() throws IOException {
+        // + is equivalent to 00 in Switzerland
+        assertTokensInclude(phoneSearchCHAnalyzer, "0041583161010", Arrays.asList("41", "41583161010", "583161010"));
+    }
+
+    public void testSearchLocalNumberWithCH() throws IOException {
+        // when omitting the international prefix swiss numbers must start with '0'
+        assertTokensInclude(phoneSearchCHAnalyzer, "0583161010", Arrays.asList("41", "41583161010", "583161010"));
+    }
+
+    /**
+     * Unlike {@link #assertTokenStreamContents(TokenStream, String[])} this only asserts whether the generated tokens
+     * contain the required ones but does not check for order. Use {@link #assertTokensInclude} if completeness is not needed.
+     */
+    private void assertTokensAreInAnyOrder(final Analyzer analyzer, final String input, final List<String> expectedTokens)
+        throws IOException {
+        final var ts = analyzer.tokenStream("test", input);
+        final var allTokens = getAllTokens(ts).toArray();
+        assertThat(allTokens, arrayContainingInAnyOrder(expectedTokens.toArray()));
+    }
+
+    /**
+     * Unlike {@link #assertTokenStreamContents(TokenStream, String[])} this only asserts whether the generated tokens
+     * contain the required ones but does not check for completeness or order.
+     */
+    private void assertTokensInclude(final Analyzer analyzer, final String input, final List<String> expectedTokens) throws IOException {
+        final var ts = analyzer.tokenStream("test", input);
+        final var allTokens = getAllTokens(ts).toArray();
+        for (final var expectedToken : expectedTokens) {
+            assertThat(allTokens, hasItemInArray(expectedToken));
+        }
+    }
+
+    /**
+     * Unlike {@link #assertTokenStreamContents(TokenStream, String[])} this only asserts whether the generated tokens
+     * contain the required ones but does not check for completeness or order.
+     * This uses {@link #phoneAnalyzer}.
+     */
+    private void assertTokensInclude(final String input, final List<String> expectedTokens) throws IOException {
+        this.assertTokensInclude(phoneAnalyzer, input, expectedTokens);
+    }
+
+    private List<String> getAllTokens(final TokenStream ts) throws IOException {
+        final var tokens = new ArrayList<String>();
+        final var termAtt = ts.getAttribute(CharTermAttribute.class);
+        ts.reset();
+        while (ts.incrementToken()) {
+            tokens.add(termAtt.toString());
+        }
+        ts.end();
+        ts.close();
+        return tokens;
+    }
+
+}
diff --git a/plugins/analysis-phonenumber/src/test/resources/org/opensearch/analysis/phone/phone_analysis.json b/plugins/analysis-phonenumber/src/test/resources/org/opensearch/analysis/phone/phone_analysis.json
new file mode 100644
index 0000000000000..7e45177c57492
--- /dev/null
+++ b/plugins/analysis-phonenumber/src/test/resources/org/opensearch/analysis/phone/phone_analysis.json
@@ -0,0 +1,22 @@
+{
+  "index": {
+    "analysis": {
+      "analyzer": {
+        "phone": {
+          "type": "phone"
+        },
+        "phone-search": {
+          "type": "phone-search"
+        },
+        "phone-ch": {
+          "type": "phone",
+          "phone-region": "CH"
+        },
+        "phone-search-ch": {
+          "type": "phone-search",
+          "phone-region": "CH"
+        }
+      }
+    }
+  }
+}
diff --git a/plugins/analysis-phonenumber/src/yamlRestTest/java/org/opensearch/analysis/phone/PhoneNumberAnalysisClientYamlTestSuiteIT.java b/plugins/analysis-phonenumber/src/yamlRestTest/java/org/opensearch/analysis/phone/PhoneNumberAnalysisClientYamlTestSuiteIT.java
new file mode 100644
index 0000000000000..d514a3329a1a7
--- /dev/null
+++ b/plugins/analysis-phonenumber/src/yamlRestTest/java/org/opensearch/analysis/phone/PhoneNumberAnalysisClientYamlTestSuiteIT.java
@@ -0,0 +1,49 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/*
+ * Licensed to Elasticsearch under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch 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.
+ */
+/*
+ * Modifications Copyright OpenSearch Contributors. See
+ * GitHub history for details.
+ */
+
+package org.opensearch.analysis.phone;
+
+import com.carrotsearch.randomizedtesting.annotations.Name;
+import com.carrotsearch.randomizedtesting.annotations.ParametersFactory;
+
+import org.opensearch.test.rest.yaml.ClientYamlTestCandidate;
+import org.opensearch.test.rest.yaml.OpenSearchClientYamlSuiteTestCase;
+
+public class PhoneNumberAnalysisClientYamlTestSuiteIT extends OpenSearchClientYamlSuiteTestCase {
+    public PhoneNumberAnalysisClientYamlTestSuiteIT(@Name("yaml") ClientYamlTestCandidate testCandidate) {
+        super(testCandidate);
+    }
+
+    @ParametersFactory
+    public static Iterable<Object[]> parameters() throws Exception {
+        return OpenSearchClientYamlSuiteTestCase.createParameters();
+    }
+}
diff --git a/plugins/analysis-phonenumber/src/yamlRestTest/resources/rest-api-spec/test/analysis-phone/10_basic.yml b/plugins/analysis-phonenumber/src/yamlRestTest/resources/rest-api-spec/test/analysis-phone/10_basic.yml
new file mode 100644
index 0000000000000..5bea0cf4650d6
--- /dev/null
+++ b/plugins/analysis-phonenumber/src/yamlRestTest/resources/rest-api-spec/test/analysis-phone/10_basic.yml
@@ -0,0 +1,8 @@
+"Test that the plugin is loaded in OpenSearch":
+  - do:
+      cat.plugins:
+        local: true
+        h: component
+
+  - match:
+      $body: /^analysis-phonenumber\n$/
diff --git a/plugins/analysis-phonenumber/src/yamlRestTest/resources/rest-api-spec/test/analysis-phone/20_search.yml b/plugins/analysis-phonenumber/src/yamlRestTest/resources/rest-api-spec/test/analysis-phone/20_search.yml
new file mode 100644
index 0000000000000..0bd7d2c371bfc
--- /dev/null
+++ b/plugins/analysis-phonenumber/src/yamlRestTest/resources/rest-api-spec/test/analysis-phone/20_search.yml
@@ -0,0 +1,56 @@
+# Integration tests for phone analysis components
+#
+---
+"Index phone number content":
+  - do:
+      indices.create:
+        index: test
+        body:
+          settings:
+            index:
+              analysis:
+                analyzer:
+                  phone-ch:
+                    type: "phone"
+                    "phone-region": "CH"
+                  phone-search-ch:
+                    type: "phone-search"
+                    "phone-region": "CH"
+          mappings:
+            properties:
+              phone:
+                type: text
+                analyzer: "phone"
+                search_analyzer: "phone-search"
+              phone-ch:
+                type: text
+                analyzer: "phone-ch"
+                search_analyzer: "phone-search-ch"
+
+  - do:
+      index:
+        index:  test
+        id:     1
+        body:   { "phone": "+41 58 316 10 10", "phone-ch": "058 316 10 10" }
+  - do:
+      indices.refresh: {}
+
+  - do:
+      search:
+        rest_total_hits_as_int: true
+        index: test
+        body:
+          query:
+            match:
+              "phone": "+41583161010"
+  - match: { hits.total: 1 }
+
+  - do:
+      search:
+        rest_total_hits_as_int: true
+        index: test
+        body:
+          query:
+            match:
+              "phone-ch": "+41583161010"
+  - match: { hits.total: 1 }
diff --git a/plugins/repository-azure/build.gradle b/plugins/repository-azure/build.gradle
index 2892bdba51ba6..4baf79e619be9 100644
--- a/plugins/repository-azure/build.gradle
+++ b/plugins/repository-azure/build.gradle
@@ -48,7 +48,7 @@ dependencies {
   api 'com.azure:azure-json:1.1.0'
   api 'com.azure:azure-xml:1.1.0'
   api 'com.azure:azure-storage-common:12.25.1'
-  api 'com.azure:azure-core-http-netty:1.15.3'
+  api 'com.azure:azure-core-http-netty:1.15.4'
   api "io.netty:netty-codec-dns:${versions.netty}"
   api "io.netty:netty-codec-socks:${versions.netty}"
   api "io.netty:netty-codec-http2:${versions.netty}"
diff --git a/plugins/repository-azure/licenses/azure-core-http-netty-1.15.3.jar.sha1 b/plugins/repository-azure/licenses/azure-core-http-netty-1.15.3.jar.sha1
deleted file mode 100644
index 3cea52ba67ce5..0000000000000
--- a/plugins/repository-azure/licenses/azure-core-http-netty-1.15.3.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-03b5bd5f5c16eea71f130119dbfb1fe5239f806a
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/azure-core-http-netty-1.15.4.jar.sha1 b/plugins/repository-azure/licenses/azure-core-http-netty-1.15.4.jar.sha1
new file mode 100644
index 0000000000000..97e6fad264294
--- /dev/null
+++ b/plugins/repository-azure/licenses/azure-core-http-netty-1.15.4.jar.sha1
@@ -0,0 +1 @@
+489a38c9e6efb5ce01fbd276d8cb6c0e89000459
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/netty-codec-dns-4.1.112.Final.jar.sha1 b/plugins/repository-azure/licenses/netty-codec-dns-4.1.112.Final.jar.sha1
deleted file mode 100644
index a42a41b6387c8..0000000000000
--- a/plugins/repository-azure/licenses/netty-codec-dns-4.1.112.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-06724b184ee870ecc4d8fc36931beeb3c387b0ee
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/netty-codec-dns-4.1.114.Final.jar.sha1 b/plugins/repository-azure/licenses/netty-codec-dns-4.1.114.Final.jar.sha1
new file mode 100644
index 0000000000000..04a48547adb05
--- /dev/null
+++ b/plugins/repository-azure/licenses/netty-codec-dns-4.1.114.Final.jar.sha1
@@ -0,0 +1 @@
+35798729ba06670fb4fcd02db98d9577e363992d
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/netty-codec-http2-4.1.112.Final.jar.sha1 b/plugins/repository-azure/licenses/netty-codec-http2-4.1.112.Final.jar.sha1
deleted file mode 100644
index d4767d06b22bf..0000000000000
--- a/plugins/repository-azure/licenses/netty-codec-http2-4.1.112.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-7fa28b510f0f16f4d5d7188b86bef59e048f62f9
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/netty-codec-http2-4.1.114.Final.jar.sha1 b/plugins/repository-azure/licenses/netty-codec-http2-4.1.114.Final.jar.sha1
new file mode 100644
index 0000000000000..2c18924e33c62
--- /dev/null
+++ b/plugins/repository-azure/licenses/netty-codec-http2-4.1.114.Final.jar.sha1
@@ -0,0 +1 @@
+19ae07fdf99142a70338f8cda70a3d2edbc8e80a
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/netty-codec-socks-4.1.112.Final.jar.sha1 b/plugins/repository-azure/licenses/netty-codec-socks-4.1.112.Final.jar.sha1
deleted file mode 100644
index 5291a16c10448..0000000000000
--- a/plugins/repository-azure/licenses/netty-codec-socks-4.1.112.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-9aed7e78c467d06a47a45b5b27466380a6427e2f
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/netty-codec-socks-4.1.114.Final.jar.sha1 b/plugins/repository-azure/licenses/netty-codec-socks-4.1.114.Final.jar.sha1
new file mode 100644
index 0000000000000..acbab117e4c15
--- /dev/null
+++ b/plugins/repository-azure/licenses/netty-codec-socks-4.1.114.Final.jar.sha1
@@ -0,0 +1 @@
+42b1159cac3d196f6bdbd528e29f0fab9dbaae06
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/netty-handler-proxy-4.1.112.Final.jar.sha1 b/plugins/repository-azure/licenses/netty-handler-proxy-4.1.112.Final.jar.sha1
deleted file mode 100644
index cf50574b87da0..0000000000000
--- a/plugins/repository-azure/licenses/netty-handler-proxy-4.1.112.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-b23c87a85451b3b0e7c3e8e89698cea6831a8418
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/netty-handler-proxy-4.1.114.Final.jar.sha1 b/plugins/repository-azure/licenses/netty-handler-proxy-4.1.114.Final.jar.sha1
new file mode 100644
index 0000000000000..891ed0a444dc2
--- /dev/null
+++ b/plugins/repository-azure/licenses/netty-handler-proxy-4.1.114.Final.jar.sha1
@@ -0,0 +1 @@
+a01071edffb4812009312b461ce5f160cdec9b75
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/netty-resolver-dns-4.1.112.Final.jar.sha1 b/plugins/repository-azure/licenses/netty-resolver-dns-4.1.112.Final.jar.sha1
deleted file mode 100644
index 24e8177190e04..0000000000000
--- a/plugins/repository-azure/licenses/netty-resolver-dns-4.1.112.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-375872f1c16bb51aac016ff6ee4f5d28b1288d4d
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/netty-resolver-dns-4.1.114.Final.jar.sha1 b/plugins/repository-azure/licenses/netty-resolver-dns-4.1.114.Final.jar.sha1
new file mode 100644
index 0000000000000..7df7a05cd7345
--- /dev/null
+++ b/plugins/repository-azure/licenses/netty-resolver-dns-4.1.114.Final.jar.sha1
@@ -0,0 +1 @@
+2fed36ff50059ded641fa5064963c4b4313512f3
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/netty-transport-native-unix-common-4.1.112.Final.jar.sha1 b/plugins/repository-azure/licenses/netty-transport-native-unix-common-4.1.112.Final.jar.sha1
deleted file mode 100644
index 8dad0e3104dc8..0000000000000
--- a/plugins/repository-azure/licenses/netty-transport-native-unix-common-4.1.112.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-b50ff619cdcdc48e748cba3405c9988529f28f60
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/netty-transport-native-unix-common-4.1.114.Final.jar.sha1 b/plugins/repository-azure/licenses/netty-transport-native-unix-common-4.1.114.Final.jar.sha1
new file mode 100644
index 0000000000000..a80b9e51be74b
--- /dev/null
+++ b/plugins/repository-azure/licenses/netty-transport-native-unix-common-4.1.114.Final.jar.sha1
@@ -0,0 +1 @@
+d1171bb99411f282068f49d780cedf8c9adeabfd
\ No newline at end of file
diff --git a/plugins/repository-hdfs/licenses/netty-all-4.1.112.Final.jar.sha1 b/plugins/repository-hdfs/licenses/netty-all-4.1.112.Final.jar.sha1
deleted file mode 100644
index 7c36b789e839c..0000000000000
--- a/plugins/repository-hdfs/licenses/netty-all-4.1.112.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-d6b2e543749a86957777a46cf68aaa337cc558cb
\ No newline at end of file
diff --git a/plugins/repository-hdfs/licenses/netty-all-4.1.114.Final.jar.sha1 b/plugins/repository-hdfs/licenses/netty-all-4.1.114.Final.jar.sha1
new file mode 100644
index 0000000000000..32022e1b2eaa4
--- /dev/null
+++ b/plugins/repository-hdfs/licenses/netty-all-4.1.114.Final.jar.sha1
@@ -0,0 +1 @@
+08134b298d48eec5ddf2e3674a978b52e4667304
\ No newline at end of file
diff --git a/plugins/repository-s3/licenses/netty-buffer-4.1.112.Final.jar.sha1 b/plugins/repository-s3/licenses/netty-buffer-4.1.112.Final.jar.sha1
deleted file mode 100644
index 5c26883046fed..0000000000000
--- a/plugins/repository-s3/licenses/netty-buffer-4.1.112.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-bdc12df04bb6858890b8aa108060b5b365a26102
\ No newline at end of file
diff --git a/plugins/repository-s3/licenses/netty-buffer-4.1.114.Final.jar.sha1 b/plugins/repository-s3/licenses/netty-buffer-4.1.114.Final.jar.sha1
new file mode 100644
index 0000000000000..8cb83fc367d78
--- /dev/null
+++ b/plugins/repository-s3/licenses/netty-buffer-4.1.114.Final.jar.sha1
@@ -0,0 +1 @@
+f1d77d15c0b781cd9395a2a956262766fd0c7602
\ No newline at end of file
diff --git a/plugins/repository-s3/licenses/netty-codec-4.1.112.Final.jar.sha1 b/plugins/repository-s3/licenses/netty-codec-4.1.112.Final.jar.sha1
deleted file mode 100644
index 1fd224fdd0b44..0000000000000
--- a/plugins/repository-s3/licenses/netty-codec-4.1.112.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-c87f2ec3d9a97bd2b793d16817abb2bab93a7fc3
\ No newline at end of file
diff --git a/plugins/repository-s3/licenses/netty-codec-4.1.114.Final.jar.sha1 b/plugins/repository-s3/licenses/netty-codec-4.1.114.Final.jar.sha1
new file mode 100644
index 0000000000000..1be26fee34d46
--- /dev/null
+++ b/plugins/repository-s3/licenses/netty-codec-4.1.114.Final.jar.sha1
@@ -0,0 +1 @@
+5a49dfa2828d64bf756f670e63259115332744cf
\ No newline at end of file
diff --git a/plugins/repository-s3/licenses/netty-codec-http-4.1.112.Final.jar.sha1 b/plugins/repository-s3/licenses/netty-codec-http-4.1.112.Final.jar.sha1
deleted file mode 100644
index 22d35128c3ad5..0000000000000
--- a/plugins/repository-s3/licenses/netty-codec-http-4.1.112.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-81af1040bfa977f98dd0e1bd9639513ea862ca04
\ No newline at end of file
diff --git a/plugins/repository-s3/licenses/netty-codec-http-4.1.114.Final.jar.sha1 b/plugins/repository-s3/licenses/netty-codec-http-4.1.114.Final.jar.sha1
new file mode 100644
index 0000000000000..e683773245716
--- /dev/null
+++ b/plugins/repository-s3/licenses/netty-codec-http-4.1.114.Final.jar.sha1
@@ -0,0 +1 @@
+fbce5a53884275662e68aaad70f88bf7e5d04164
\ No newline at end of file
diff --git a/plugins/repository-s3/licenses/netty-codec-http2-4.1.112.Final.jar.sha1 b/plugins/repository-s3/licenses/netty-codec-http2-4.1.112.Final.jar.sha1
deleted file mode 100644
index d4767d06b22bf..0000000000000
--- a/plugins/repository-s3/licenses/netty-codec-http2-4.1.112.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-7fa28b510f0f16f4d5d7188b86bef59e048f62f9
\ No newline at end of file
diff --git a/plugins/repository-s3/licenses/netty-codec-http2-4.1.114.Final.jar.sha1 b/plugins/repository-s3/licenses/netty-codec-http2-4.1.114.Final.jar.sha1
new file mode 100644
index 0000000000000..2c18924e33c62
--- /dev/null
+++ b/plugins/repository-s3/licenses/netty-codec-http2-4.1.114.Final.jar.sha1
@@ -0,0 +1 @@
+19ae07fdf99142a70338f8cda70a3d2edbc8e80a
\ No newline at end of file
diff --git a/plugins/repository-s3/licenses/netty-common-4.1.112.Final.jar.sha1 b/plugins/repository-s3/licenses/netty-common-4.1.112.Final.jar.sha1
deleted file mode 100644
index 47af3100f0f2d..0000000000000
--- a/plugins/repository-s3/licenses/netty-common-4.1.112.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-b2798069092a981a832b7510d0462ee9efb7a80e
\ No newline at end of file
diff --git a/plugins/repository-s3/licenses/netty-common-4.1.114.Final.jar.sha1 b/plugins/repository-s3/licenses/netty-common-4.1.114.Final.jar.sha1
new file mode 100644
index 0000000000000..74ce939dc6190
--- /dev/null
+++ b/plugins/repository-s3/licenses/netty-common-4.1.114.Final.jar.sha1
@@ -0,0 +1 @@
+862712e292b162c8ccaa7847a6a54df8178f77e5
\ No newline at end of file
diff --git a/plugins/repository-s3/licenses/netty-handler-4.1.112.Final.jar.sha1 b/plugins/repository-s3/licenses/netty-handler-4.1.112.Final.jar.sha1
deleted file mode 100644
index 8b30272861770..0000000000000
--- a/plugins/repository-s3/licenses/netty-handler-4.1.112.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-3d5e2d5bcc6baeeb8c13a230980c6132a778e036
\ No newline at end of file
diff --git a/plugins/repository-s3/licenses/netty-handler-4.1.114.Final.jar.sha1 b/plugins/repository-s3/licenses/netty-handler-4.1.114.Final.jar.sha1
new file mode 100644
index 0000000000000..c431976b6fbd2
--- /dev/null
+++ b/plugins/repository-s3/licenses/netty-handler-4.1.114.Final.jar.sha1
@@ -0,0 +1 @@
+e56fbde4b9aa628eed15a5dbfbeb97877db88146
\ No newline at end of file
diff --git a/plugins/repository-s3/licenses/netty-resolver-4.1.112.Final.jar.sha1 b/plugins/repository-s3/licenses/netty-resolver-4.1.112.Final.jar.sha1
deleted file mode 100644
index 1a094fa19a623..0000000000000
--- a/plugins/repository-s3/licenses/netty-resolver-4.1.112.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-58a631d9d44c4ed7cc0dcc9cffa6641da9374d72
\ No newline at end of file
diff --git a/plugins/repository-s3/licenses/netty-resolver-4.1.114.Final.jar.sha1 b/plugins/repository-s3/licenses/netty-resolver-4.1.114.Final.jar.sha1
new file mode 100644
index 0000000000000..e8080a5b2acb1
--- /dev/null
+++ b/plugins/repository-s3/licenses/netty-resolver-4.1.114.Final.jar.sha1
@@ -0,0 +1 @@
+10b23784b23d6a948930f52ba82874f1291b5873
\ No newline at end of file
diff --git a/plugins/repository-s3/licenses/netty-transport-4.1.112.Final.jar.sha1 b/plugins/repository-s3/licenses/netty-transport-4.1.112.Final.jar.sha1
deleted file mode 100644
index 5fbfde0836e0c..0000000000000
--- a/plugins/repository-s3/licenses/netty-transport-4.1.112.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-77cd136dd3843f5e7cbcf68c824975d745c49ddb
\ No newline at end of file
diff --git a/plugins/repository-s3/licenses/netty-transport-4.1.114.Final.jar.sha1 b/plugins/repository-s3/licenses/netty-transport-4.1.114.Final.jar.sha1
new file mode 100644
index 0000000000000..fb2d518789a18
--- /dev/null
+++ b/plugins/repository-s3/licenses/netty-transport-4.1.114.Final.jar.sha1
@@ -0,0 +1 @@
+e0225a575f487904be8517092cbd74e01913533c
\ No newline at end of file
diff --git a/plugins/repository-s3/licenses/netty-transport-classes-epoll-4.1.112.Final.jar.sha1 b/plugins/repository-s3/licenses/netty-transport-classes-epoll-4.1.112.Final.jar.sha1
deleted file mode 100644
index 0196dacfe92ba..0000000000000
--- a/plugins/repository-s3/licenses/netty-transport-classes-epoll-4.1.112.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-67e590356eb53c20aaabd67f61ae66f628e62e3d
\ No newline at end of file
diff --git a/plugins/repository-s3/licenses/netty-transport-classes-epoll-4.1.114.Final.jar.sha1 b/plugins/repository-s3/licenses/netty-transport-classes-epoll-4.1.114.Final.jar.sha1
new file mode 100644
index 0000000000000..7120cd93e5c0d
--- /dev/null
+++ b/plugins/repository-s3/licenses/netty-transport-classes-epoll-4.1.114.Final.jar.sha1
@@ -0,0 +1 @@
+f442c794e6fe89e6974f058bf393353e01fb927d
\ No newline at end of file
diff --git a/plugins/repository-s3/licenses/netty-transport-native-unix-common-4.1.112.Final.jar.sha1 b/plugins/repository-s3/licenses/netty-transport-native-unix-common-4.1.112.Final.jar.sha1
deleted file mode 100644
index 8dad0e3104dc8..0000000000000
--- a/plugins/repository-s3/licenses/netty-transport-native-unix-common-4.1.112.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-b50ff619cdcdc48e748cba3405c9988529f28f60
\ No newline at end of file
diff --git a/plugins/repository-s3/licenses/netty-transport-native-unix-common-4.1.114.Final.jar.sha1 b/plugins/repository-s3/licenses/netty-transport-native-unix-common-4.1.114.Final.jar.sha1
new file mode 100644
index 0000000000000..a80b9e51be74b
--- /dev/null
+++ b/plugins/repository-s3/licenses/netty-transport-native-unix-common-4.1.114.Final.jar.sha1
@@ -0,0 +1 @@
+d1171bb99411f282068f49d780cedf8c9adeabfd
\ No newline at end of file
diff --git a/plugins/repository-s3/src/main/java/org/opensearch/repositories/s3/S3AsyncService.java b/plugins/repository-s3/src/main/java/org/opensearch/repositories/s3/S3AsyncService.java
index d691cad9c9d03..8bbef168de89c 100644
--- a/plugins/repository-s3/src/main/java/org/opensearch/repositories/s3/S3AsyncService.java
+++ b/plugins/repository-s3/src/main/java/org/opensearch/repositories/s3/S3AsyncService.java
@@ -18,6 +18,7 @@
 import software.amazon.awssdk.core.client.config.ClientAsyncConfiguration;
 import software.amazon.awssdk.core.client.config.ClientOverrideConfiguration;
 import software.amazon.awssdk.core.client.config.SdkAdvancedAsyncClientOption;
+import software.amazon.awssdk.core.retry.RetryMode;
 import software.amazon.awssdk.core.retry.RetryPolicy;
 import software.amazon.awssdk.core.retry.backoff.BackoffStrategy;
 import software.amazon.awssdk.http.async.SdkAsyncHttpClient;
@@ -239,7 +240,9 @@ static ClientOverrideConfiguration buildOverrideConfiguration(final S3ClientSett
                 RetryPolicy.builder()
                     .numRetries(clientSettings.maxRetries)
                     .throttlingBackoffStrategy(
-                        clientSettings.throttleRetries ? BackoffStrategy.defaultThrottlingStrategy() : BackoffStrategy.none()
+                        clientSettings.throttleRetries
+                            ? BackoffStrategy.defaultThrottlingStrategy(RetryMode.STANDARD)
+                            : BackoffStrategy.none()
                     )
                     .build()
             )
diff --git a/plugins/repository-s3/src/main/java/org/opensearch/repositories/s3/S3Service.java b/plugins/repository-s3/src/main/java/org/opensearch/repositories/s3/S3Service.java
index fe81da31432f4..3d5e121778ba9 100644
--- a/plugins/repository-s3/src/main/java/org/opensearch/repositories/s3/S3Service.java
+++ b/plugins/repository-s3/src/main/java/org/opensearch/repositories/s3/S3Service.java
@@ -42,6 +42,7 @@
 import software.amazon.awssdk.core.client.config.ClientOverrideConfiguration;
 import software.amazon.awssdk.core.client.config.SdkAdvancedClientOption;
 import software.amazon.awssdk.core.exception.SdkException;
+import software.amazon.awssdk.core.retry.RetryMode;
 import software.amazon.awssdk.core.retry.RetryPolicy;
 import software.amazon.awssdk.core.retry.backoff.BackoffStrategy;
 import software.amazon.awssdk.http.SystemPropertyTlsKeyManagersProvider;
@@ -330,6 +331,8 @@ static ClientOverrideConfiguration buildOverrideConfiguration(final S3ClientSett
         );
         if (!clientSettings.throttleRetries) {
             retryPolicy.throttlingBackoffStrategy(BackoffStrategy.none());
+        } else {
+            retryPolicy.throttlingBackoffStrategy(BackoffStrategy.defaultThrottlingStrategy(RetryMode.STANDARD));
         }
         return clientOverrideConfiguration.retryPolicy(retryPolicy.build()).build();
     }
diff --git a/plugins/repository-s3/src/test/java/org/opensearch/repositories/s3/AwsS3ServiceImplTests.java b/plugins/repository-s3/src/test/java/org/opensearch/repositories/s3/AwsS3ServiceImplTests.java
index b80b857644f2a..e7312157d7a33 100644
--- a/plugins/repository-s3/src/test/java/org/opensearch/repositories/s3/AwsS3ServiceImplTests.java
+++ b/plugins/repository-s3/src/test/java/org/opensearch/repositories/s3/AwsS3ServiceImplTests.java
@@ -35,6 +35,7 @@
 import software.amazon.awssdk.auth.credentials.AwsCredentialsProvider;
 import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider;
 import software.amazon.awssdk.core.client.config.ClientOverrideConfiguration;
+import software.amazon.awssdk.core.retry.RetryMode;
 import software.amazon.awssdk.core.retry.backoff.BackoffStrategy;
 import software.amazon.awssdk.http.apache.ProxyConfiguration;
 
@@ -364,7 +365,7 @@ private void launchAWSConfigurationTest(
         if (expectedUseThrottleRetries) {
             assertThat(
                 clientOverrideConfiguration.retryPolicy().get().throttlingBackoffStrategy(),
-                is(BackoffStrategy.defaultThrottlingStrategy())
+                is(BackoffStrategy.defaultThrottlingStrategy(RetryMode.STANDARD))
             );
         } else {
             assertThat(clientOverrideConfiguration.retryPolicy().get().throttlingBackoffStrategy(), is(BackoffStrategy.none()));
diff --git a/plugins/transport-nio/licenses/netty-buffer-4.1.112.Final.jar.sha1 b/plugins/transport-nio/licenses/netty-buffer-4.1.112.Final.jar.sha1
deleted file mode 100644
index 5c26883046fed..0000000000000
--- a/plugins/transport-nio/licenses/netty-buffer-4.1.112.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-bdc12df04bb6858890b8aa108060b5b365a26102
\ No newline at end of file
diff --git a/plugins/transport-nio/licenses/netty-buffer-4.1.114.Final.jar.sha1 b/plugins/transport-nio/licenses/netty-buffer-4.1.114.Final.jar.sha1
new file mode 100644
index 0000000000000..8cb83fc367d78
--- /dev/null
+++ b/plugins/transport-nio/licenses/netty-buffer-4.1.114.Final.jar.sha1
@@ -0,0 +1 @@
+f1d77d15c0b781cd9395a2a956262766fd0c7602
\ No newline at end of file
diff --git a/plugins/transport-nio/licenses/netty-codec-4.1.112.Final.jar.sha1 b/plugins/transport-nio/licenses/netty-codec-4.1.112.Final.jar.sha1
deleted file mode 100644
index 1fd224fdd0b44..0000000000000
--- a/plugins/transport-nio/licenses/netty-codec-4.1.112.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-c87f2ec3d9a97bd2b793d16817abb2bab93a7fc3
\ No newline at end of file
diff --git a/plugins/transport-nio/licenses/netty-codec-4.1.114.Final.jar.sha1 b/plugins/transport-nio/licenses/netty-codec-4.1.114.Final.jar.sha1
new file mode 100644
index 0000000000000..1be26fee34d46
--- /dev/null
+++ b/plugins/transport-nio/licenses/netty-codec-4.1.114.Final.jar.sha1
@@ -0,0 +1 @@
+5a49dfa2828d64bf756f670e63259115332744cf
\ No newline at end of file
diff --git a/plugins/transport-nio/licenses/netty-codec-http-4.1.112.Final.jar.sha1 b/plugins/transport-nio/licenses/netty-codec-http-4.1.112.Final.jar.sha1
deleted file mode 100644
index 22d35128c3ad5..0000000000000
--- a/plugins/transport-nio/licenses/netty-codec-http-4.1.112.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-81af1040bfa977f98dd0e1bd9639513ea862ca04
\ No newline at end of file
diff --git a/plugins/transport-nio/licenses/netty-codec-http-4.1.114.Final.jar.sha1 b/plugins/transport-nio/licenses/netty-codec-http-4.1.114.Final.jar.sha1
new file mode 100644
index 0000000000000..e683773245716
--- /dev/null
+++ b/plugins/transport-nio/licenses/netty-codec-http-4.1.114.Final.jar.sha1
@@ -0,0 +1 @@
+fbce5a53884275662e68aaad70f88bf7e5d04164
\ No newline at end of file
diff --git a/plugins/transport-nio/licenses/netty-common-4.1.112.Final.jar.sha1 b/plugins/transport-nio/licenses/netty-common-4.1.112.Final.jar.sha1
deleted file mode 100644
index 47af3100f0f2d..0000000000000
--- a/plugins/transport-nio/licenses/netty-common-4.1.112.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-b2798069092a981a832b7510d0462ee9efb7a80e
\ No newline at end of file
diff --git a/plugins/transport-nio/licenses/netty-common-4.1.114.Final.jar.sha1 b/plugins/transport-nio/licenses/netty-common-4.1.114.Final.jar.sha1
new file mode 100644
index 0000000000000..74ce939dc6190
--- /dev/null
+++ b/plugins/transport-nio/licenses/netty-common-4.1.114.Final.jar.sha1
@@ -0,0 +1 @@
+862712e292b162c8ccaa7847a6a54df8178f77e5
\ No newline at end of file
diff --git a/plugins/transport-nio/licenses/netty-handler-4.1.112.Final.jar.sha1 b/plugins/transport-nio/licenses/netty-handler-4.1.112.Final.jar.sha1
deleted file mode 100644
index 8b30272861770..0000000000000
--- a/plugins/transport-nio/licenses/netty-handler-4.1.112.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-3d5e2d5bcc6baeeb8c13a230980c6132a778e036
\ No newline at end of file
diff --git a/plugins/transport-nio/licenses/netty-handler-4.1.114.Final.jar.sha1 b/plugins/transport-nio/licenses/netty-handler-4.1.114.Final.jar.sha1
new file mode 100644
index 0000000000000..c431976b6fbd2
--- /dev/null
+++ b/plugins/transport-nio/licenses/netty-handler-4.1.114.Final.jar.sha1
@@ -0,0 +1 @@
+e56fbde4b9aa628eed15a5dbfbeb97877db88146
\ No newline at end of file
diff --git a/plugins/transport-nio/licenses/netty-resolver-4.1.112.Final.jar.sha1 b/plugins/transport-nio/licenses/netty-resolver-4.1.112.Final.jar.sha1
deleted file mode 100644
index 1a094fa19a623..0000000000000
--- a/plugins/transport-nio/licenses/netty-resolver-4.1.112.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-58a631d9d44c4ed7cc0dcc9cffa6641da9374d72
\ No newline at end of file
diff --git a/plugins/transport-nio/licenses/netty-resolver-4.1.114.Final.jar.sha1 b/plugins/transport-nio/licenses/netty-resolver-4.1.114.Final.jar.sha1
new file mode 100644
index 0000000000000..e8080a5b2acb1
--- /dev/null
+++ b/plugins/transport-nio/licenses/netty-resolver-4.1.114.Final.jar.sha1
@@ -0,0 +1 @@
+10b23784b23d6a948930f52ba82874f1291b5873
\ No newline at end of file
diff --git a/plugins/transport-nio/licenses/netty-transport-4.1.112.Final.jar.sha1 b/plugins/transport-nio/licenses/netty-transport-4.1.112.Final.jar.sha1
deleted file mode 100644
index 5fbfde0836e0c..0000000000000
--- a/plugins/transport-nio/licenses/netty-transport-4.1.112.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-77cd136dd3843f5e7cbcf68c824975d745c49ddb
\ No newline at end of file
diff --git a/plugins/transport-nio/licenses/netty-transport-4.1.114.Final.jar.sha1 b/plugins/transport-nio/licenses/netty-transport-4.1.114.Final.jar.sha1
new file mode 100644
index 0000000000000..fb2d518789a18
--- /dev/null
+++ b/plugins/transport-nio/licenses/netty-transport-4.1.114.Final.jar.sha1
@@ -0,0 +1 @@
+e0225a575f487904be8517092cbd74e01913533c
\ No newline at end of file
diff --git a/plugins/transport-reactor-netty4/licenses/netty-buffer-4.1.112.Final.jar.sha1 b/plugins/transport-reactor-netty4/licenses/netty-buffer-4.1.112.Final.jar.sha1
deleted file mode 100644
index 5c26883046fed..0000000000000
--- a/plugins/transport-reactor-netty4/licenses/netty-buffer-4.1.112.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-bdc12df04bb6858890b8aa108060b5b365a26102
\ No newline at end of file
diff --git a/plugins/transport-reactor-netty4/licenses/netty-buffer-4.1.114.Final.jar.sha1 b/plugins/transport-reactor-netty4/licenses/netty-buffer-4.1.114.Final.jar.sha1
new file mode 100644
index 0000000000000..8cb83fc367d78
--- /dev/null
+++ b/plugins/transport-reactor-netty4/licenses/netty-buffer-4.1.114.Final.jar.sha1
@@ -0,0 +1 @@
+f1d77d15c0b781cd9395a2a956262766fd0c7602
\ No newline at end of file
diff --git a/plugins/transport-reactor-netty4/licenses/netty-codec-4.1.112.Final.jar.sha1 b/plugins/transport-reactor-netty4/licenses/netty-codec-4.1.112.Final.jar.sha1
deleted file mode 100644
index 1fd224fdd0b44..0000000000000
--- a/plugins/transport-reactor-netty4/licenses/netty-codec-4.1.112.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-c87f2ec3d9a97bd2b793d16817abb2bab93a7fc3
\ No newline at end of file
diff --git a/plugins/transport-reactor-netty4/licenses/netty-codec-4.1.114.Final.jar.sha1 b/plugins/transport-reactor-netty4/licenses/netty-codec-4.1.114.Final.jar.sha1
new file mode 100644
index 0000000000000..1be26fee34d46
--- /dev/null
+++ b/plugins/transport-reactor-netty4/licenses/netty-codec-4.1.114.Final.jar.sha1
@@ -0,0 +1 @@
+5a49dfa2828d64bf756f670e63259115332744cf
\ No newline at end of file
diff --git a/plugins/transport-reactor-netty4/licenses/netty-codec-dns-4.1.112.Final.jar.sha1 b/plugins/transport-reactor-netty4/licenses/netty-codec-dns-4.1.112.Final.jar.sha1
deleted file mode 100644
index a42a41b6387c8..0000000000000
--- a/plugins/transport-reactor-netty4/licenses/netty-codec-dns-4.1.112.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-06724b184ee870ecc4d8fc36931beeb3c387b0ee
\ No newline at end of file
diff --git a/plugins/transport-reactor-netty4/licenses/netty-codec-dns-4.1.114.Final.jar.sha1 b/plugins/transport-reactor-netty4/licenses/netty-codec-dns-4.1.114.Final.jar.sha1
new file mode 100644
index 0000000000000..04a48547adb05
--- /dev/null
+++ b/plugins/transport-reactor-netty4/licenses/netty-codec-dns-4.1.114.Final.jar.sha1
@@ -0,0 +1 @@
+35798729ba06670fb4fcd02db98d9577e363992d
\ No newline at end of file
diff --git a/plugins/transport-reactor-netty4/licenses/netty-codec-http-4.1.112.Final.jar.sha1 b/plugins/transport-reactor-netty4/licenses/netty-codec-http-4.1.112.Final.jar.sha1
deleted file mode 100644
index 22d35128c3ad5..0000000000000
--- a/plugins/transport-reactor-netty4/licenses/netty-codec-http-4.1.112.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-81af1040bfa977f98dd0e1bd9639513ea862ca04
\ No newline at end of file
diff --git a/plugins/transport-reactor-netty4/licenses/netty-codec-http-4.1.114.Final.jar.sha1 b/plugins/transport-reactor-netty4/licenses/netty-codec-http-4.1.114.Final.jar.sha1
new file mode 100644
index 0000000000000..e683773245716
--- /dev/null
+++ b/plugins/transport-reactor-netty4/licenses/netty-codec-http-4.1.114.Final.jar.sha1
@@ -0,0 +1 @@
+fbce5a53884275662e68aaad70f88bf7e5d04164
\ No newline at end of file
diff --git a/plugins/transport-reactor-netty4/licenses/netty-codec-http2-4.1.112.Final.jar.sha1 b/plugins/transport-reactor-netty4/licenses/netty-codec-http2-4.1.112.Final.jar.sha1
deleted file mode 100644
index d4767d06b22bf..0000000000000
--- a/plugins/transport-reactor-netty4/licenses/netty-codec-http2-4.1.112.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-7fa28b510f0f16f4d5d7188b86bef59e048f62f9
\ No newline at end of file
diff --git a/plugins/transport-reactor-netty4/licenses/netty-codec-http2-4.1.114.Final.jar.sha1 b/plugins/transport-reactor-netty4/licenses/netty-codec-http2-4.1.114.Final.jar.sha1
new file mode 100644
index 0000000000000..2c18924e33c62
--- /dev/null
+++ b/plugins/transport-reactor-netty4/licenses/netty-codec-http2-4.1.114.Final.jar.sha1
@@ -0,0 +1 @@
+19ae07fdf99142a70338f8cda70a3d2edbc8e80a
\ No newline at end of file
diff --git a/plugins/transport-reactor-netty4/licenses/netty-common-4.1.112.Final.jar.sha1 b/plugins/transport-reactor-netty4/licenses/netty-common-4.1.112.Final.jar.sha1
deleted file mode 100644
index 47af3100f0f2d..0000000000000
--- a/plugins/transport-reactor-netty4/licenses/netty-common-4.1.112.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-b2798069092a981a832b7510d0462ee9efb7a80e
\ No newline at end of file
diff --git a/plugins/transport-reactor-netty4/licenses/netty-common-4.1.114.Final.jar.sha1 b/plugins/transport-reactor-netty4/licenses/netty-common-4.1.114.Final.jar.sha1
new file mode 100644
index 0000000000000..74ce939dc6190
--- /dev/null
+++ b/plugins/transport-reactor-netty4/licenses/netty-common-4.1.114.Final.jar.sha1
@@ -0,0 +1 @@
+862712e292b162c8ccaa7847a6a54df8178f77e5
\ No newline at end of file
diff --git a/plugins/transport-reactor-netty4/licenses/netty-handler-4.1.112.Final.jar.sha1 b/plugins/transport-reactor-netty4/licenses/netty-handler-4.1.112.Final.jar.sha1
deleted file mode 100644
index 8b30272861770..0000000000000
--- a/plugins/transport-reactor-netty4/licenses/netty-handler-4.1.112.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-3d5e2d5bcc6baeeb8c13a230980c6132a778e036
\ No newline at end of file
diff --git a/plugins/transport-reactor-netty4/licenses/netty-handler-4.1.114.Final.jar.sha1 b/plugins/transport-reactor-netty4/licenses/netty-handler-4.1.114.Final.jar.sha1
new file mode 100644
index 0000000000000..c431976b6fbd2
--- /dev/null
+++ b/plugins/transport-reactor-netty4/licenses/netty-handler-4.1.114.Final.jar.sha1
@@ -0,0 +1 @@
+e56fbde4b9aa628eed15a5dbfbeb97877db88146
\ No newline at end of file
diff --git a/plugins/transport-reactor-netty4/licenses/netty-resolver-4.1.112.Final.jar.sha1 b/plugins/transport-reactor-netty4/licenses/netty-resolver-4.1.112.Final.jar.sha1
deleted file mode 100644
index 1a094fa19a623..0000000000000
--- a/plugins/transport-reactor-netty4/licenses/netty-resolver-4.1.112.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-58a631d9d44c4ed7cc0dcc9cffa6641da9374d72
\ No newline at end of file
diff --git a/plugins/transport-reactor-netty4/licenses/netty-resolver-4.1.114.Final.jar.sha1 b/plugins/transport-reactor-netty4/licenses/netty-resolver-4.1.114.Final.jar.sha1
new file mode 100644
index 0000000000000..e8080a5b2acb1
--- /dev/null
+++ b/plugins/transport-reactor-netty4/licenses/netty-resolver-4.1.114.Final.jar.sha1
@@ -0,0 +1 @@
+10b23784b23d6a948930f52ba82874f1291b5873
\ No newline at end of file
diff --git a/plugins/transport-reactor-netty4/licenses/netty-resolver-dns-4.1.112.Final.jar.sha1 b/plugins/transport-reactor-netty4/licenses/netty-resolver-dns-4.1.112.Final.jar.sha1
deleted file mode 100644
index 24e8177190e04..0000000000000
--- a/plugins/transport-reactor-netty4/licenses/netty-resolver-dns-4.1.112.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-375872f1c16bb51aac016ff6ee4f5d28b1288d4d
\ No newline at end of file
diff --git a/plugins/transport-reactor-netty4/licenses/netty-resolver-dns-4.1.114.Final.jar.sha1 b/plugins/transport-reactor-netty4/licenses/netty-resolver-dns-4.1.114.Final.jar.sha1
new file mode 100644
index 0000000000000..7df7a05cd7345
--- /dev/null
+++ b/plugins/transport-reactor-netty4/licenses/netty-resolver-dns-4.1.114.Final.jar.sha1
@@ -0,0 +1 @@
+2fed36ff50059ded641fa5064963c4b4313512f3
\ No newline at end of file
diff --git a/plugins/transport-reactor-netty4/licenses/netty-transport-4.1.112.Final.jar.sha1 b/plugins/transport-reactor-netty4/licenses/netty-transport-4.1.112.Final.jar.sha1
deleted file mode 100644
index 5fbfde0836e0c..0000000000000
--- a/plugins/transport-reactor-netty4/licenses/netty-transport-4.1.112.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-77cd136dd3843f5e7cbcf68c824975d745c49ddb
\ No newline at end of file
diff --git a/plugins/transport-reactor-netty4/licenses/netty-transport-4.1.114.Final.jar.sha1 b/plugins/transport-reactor-netty4/licenses/netty-transport-4.1.114.Final.jar.sha1
new file mode 100644
index 0000000000000..fb2d518789a18
--- /dev/null
+++ b/plugins/transport-reactor-netty4/licenses/netty-transport-4.1.114.Final.jar.sha1
@@ -0,0 +1 @@
+e0225a575f487904be8517092cbd74e01913533c
\ No newline at end of file
diff --git a/plugins/transport-reactor-netty4/licenses/netty-transport-native-unix-common-4.1.112.Final.jar.sha1 b/plugins/transport-reactor-netty4/licenses/netty-transport-native-unix-common-4.1.112.Final.jar.sha1
deleted file mode 100644
index 8dad0e3104dc8..0000000000000
--- a/plugins/transport-reactor-netty4/licenses/netty-transport-native-unix-common-4.1.112.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-b50ff619cdcdc48e748cba3405c9988529f28f60
\ No newline at end of file
diff --git a/plugins/transport-reactor-netty4/licenses/netty-transport-native-unix-common-4.1.114.Final.jar.sha1 b/plugins/transport-reactor-netty4/licenses/netty-transport-native-unix-common-4.1.114.Final.jar.sha1
new file mode 100644
index 0000000000000..a80b9e51be74b
--- /dev/null
+++ b/plugins/transport-reactor-netty4/licenses/netty-transport-native-unix-common-4.1.114.Final.jar.sha1
@@ -0,0 +1 @@
+d1171bb99411f282068f49d780cedf8c9adeabfd
\ No newline at end of file
diff --git a/plugins/transport-reactor-netty4/src/javaRestTest/java/org/opensearch/rest/ReactorNetty4StreamingIT.java b/plugins/transport-reactor-netty4/src/javaRestTest/java/org/opensearch/rest/ReactorNetty4StreamingIT.java
index 6f3895fffa437..1b60023da0329 100644
--- a/plugins/transport-reactor-netty4/src/javaRestTest/java/org/opensearch/rest/ReactorNetty4StreamingIT.java
+++ b/plugins/transport-reactor-netty4/src/javaRestTest/java/org/opensearch/rest/ReactorNetty4StreamingIT.java
@@ -21,6 +21,7 @@
 import java.nio.ByteBuffer;
 import java.nio.charset.StandardCharsets;
 import java.time.Duration;
+import java.util.Locale;
 import java.util.stream.IntStream;
 import java.util.stream.Stream;
 
@@ -297,4 +298,31 @@ public void testStreamingBadStream() throws IOException {
         assertThat(streamingResponse.getStatusLine().getStatusCode(), equalTo(200));
         assertThat(streamingResponse.getWarnings(), empty());
     }
+
+    public void testStreamingLargeDocument() throws IOException {
+        final Stream<String> stream = Stream.of(
+            String.format(
+                Locale.getDefault(),
+                "{ \"index\": { \"_index\": \"test-streaming\", \"_id\": \"1\" } }\n{ \"name\": \"%s\"  }\n",
+                randomAlphaOfLength(5000)
+            )
+        );
+
+        final Duration delay = Duration.ofMillis(1);
+        final StreamingRequest<ByteBuffer> streamingRequest = new StreamingRequest<>(
+            "POST",
+            "/_bulk/stream",
+            Flux.fromStream(stream).map(s -> ByteBuffer.wrap(s.getBytes(StandardCharsets.UTF_8)))
+        );
+
+        final StreamingResponse<ByteBuffer> streamingResponse = client().streamRequest(streamingRequest);
+
+        StepVerifier.create(Flux.from(streamingResponse.getBody()).map(b -> new String(b.array(), StandardCharsets.UTF_8)))
+            .expectNextMatches(s -> s.contains("\"type\":\"illegal_argument_exception\""))
+            .expectComplete()
+            .verify();
+
+        assertThat(streamingResponse.getStatusLine().getStatusCode(), equalTo(200));
+        assertThat(streamingResponse.getWarnings(), empty());
+    }
 }
diff --git a/qa/remote-clusters/docker-compose.yml b/qa/remote-clusters/docker-compose.yml
index cf6aefcf5c1a3..2112da17efe6e 100644
--- a/qa/remote-clusters/docker-compose.yml
+++ b/qa/remote-clusters/docker-compose.yml
@@ -72,3 +72,11 @@ services:
       - "9600"
     volumes:
       - ./haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro
+    depends_on:
+      - opensearch-2
+    healthcheck:
+      test: ["CMD", "timeout", "1", "bash", "-c", "cat < /dev/null > /dev/tcp/localhost/9600"]
+      interval: 2s
+      timeout: 1s
+      retries: 5
+      start_period: 15s
diff --git a/qa/smoke-test-http/src/test/java/org/opensearch/http/IdentityAuthenticationIT.java b/qa/smoke-test-http/src/test/java/org/opensearch/http/IdentityAuthenticationIT.java
index 1a806b033eb8a..14346b8910c76 100644
--- a/qa/smoke-test-http/src/test/java/org/opensearch/http/IdentityAuthenticationIT.java
+++ b/qa/smoke-test-http/src/test/java/org/opensearch/http/IdentityAuthenticationIT.java
@@ -38,7 +38,6 @@ public class IdentityAuthenticationIT extends HttpSmokeTestCase {
     protected Settings nodeSettings(int nodeOrdinal) {
         return Settings.builder()
             .put(super.nodeSettings(nodeOrdinal))
-            .put(FeatureFlags.IDENTITY, "true")
             .build();
     }
 
diff --git a/release-notes/opensearch.release-notes-2.17.1.md b/release-notes/opensearch.release-notes-2.17.1.md
new file mode 100644
index 0000000000000..2ff2bd44c3b1c
--- /dev/null
+++ b/release-notes/opensearch.release-notes-2.17.1.md
@@ -0,0 +1,16 @@
+## 2024-10-01 Version 2.17.1 Release Notes
+
+## [2.17.1]
+### Added
+- Add path prefix support to hashed prefix snapshots ([#15664](https://github.com/opensearch-project/OpenSearch/pull/15664))
+- Memory optimisations in _cluster/health API ([#15492](https://github.com/opensearch-project/OpenSearch/pull/15492))
+
+### Dependencies
+
+### Changed
+
+### Deprecated
+
+### Removed
+
+### Fixed
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/test/search.aggregation/40_range.yml b/rest-api-spec/src/main/resources/rest-api-spec/test/search.aggregation/40_range.yml
index 1e1d2b0706d6b..93ca668f93a6f 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/test/search.aggregation/40_range.yml
+++ b/rest-api-spec/src/main/resources/rest-api-spec/test/search.aggregation/40_range.yml
@@ -535,8 +535,8 @@ setup:
 ---
 "Double range profiler shows filter rewrite info":
   - skip:
-      version: " - 2.99.99"
-      reason: debug info for filter rewrite added in 3.0.0 (to be backported to 2.15.0)
+      version: " - 2.15.99"
+      reason: debug info for filter rewrite was added in 2.16.0
 
   - do:
       indices.create:
diff --git a/server/build.gradle b/server/build.gradle
index 83a04ef12d13b..eccaf8a127647 100644
--- a/server/build.gradle
+++ b/server/build.gradle
@@ -407,6 +407,8 @@ tasks.named("sourcesJar").configure {
 /** Compares the current build against a laltest released version or the version supplied through 'japicmp.compare.version' system property */
 tasks.register("japicmp", me.champeau.gradle.japicmp.JapicmpTask) {
     logger.info("Comparing public APIs from ${version} to ${japicmpCompareTarget}")
+    // See please https://github.com/siom79/japicmp/issues/201
+    compatibilityChangeExcludes = [ "METHOD_ABSTRACT_NOW_DEFAULT" ]
     oldClasspath.from(files("${buildDir}/japicmp-target/opensearch-${japicmpCompareTarget}.jar"))
     newClasspath.from(tasks.named('jar'))
     onlyModified = true
diff --git a/server/src/internalClusterTest/java/org/opensearch/gateway/remote/RemotePublicationConfigurationIT.java b/server/src/internalClusterTest/java/org/opensearch/gateway/remote/RemotePublicationConfigurationIT.java
index 1d19a4bfd1af5..98859f517aad4 100644
--- a/server/src/internalClusterTest/java/org/opensearch/gateway/remote/RemotePublicationConfigurationIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/gateway/remote/RemotePublicationConfigurationIT.java
@@ -18,6 +18,7 @@
 import org.opensearch.test.InternalSettingsPlugin;
 import org.opensearch.test.OpenSearchIntegTestCase;
 import org.opensearch.test.transport.MockTransportService;
+import org.junit.Assert;
 import org.junit.Before;
 
 import java.util.Collection;
@@ -118,6 +119,31 @@ public Settings.Builder remoteWithRoutingTableNodeSetting() {
             .put(REMOTE_CLUSTER_STATE_ENABLED_SETTING.getKey(), true);
     }
 
+    public void testRemoteClusterStateServiceNotInitialized_WhenNodeAttributesNotPresent() {
+        internalCluster().startClusterManagerOnlyNode();
+        internalCluster().startDataOnlyNodes(2);
+
+        ensureStableCluster(3);
+        ensureGreen();
+
+        internalCluster().getDataOrClusterManagerNodeInstances(RemoteClusterStateService.class).forEach(Assert::assertNull);
+    }
+
+    public void testServiceInitialized_WhenNodeAttributesPresent() {
+        internalCluster().startClusterManagerOnlyNode(
+            buildRemoteStateNodeAttributes(REPOSITORY_NAME, segmentRepoPath, ReloadableFsRepository.TYPE)
+        );
+        internalCluster().startDataOnlyNodes(
+            2,
+            buildRemoteStateNodeAttributes(REPOSITORY_NAME, segmentRepoPath, ReloadableFsRepository.TYPE)
+        );
+
+        ensureStableCluster(3);
+        ensureGreen();
+
+        internalCluster().getDataOrClusterManagerNodeInstances(RemoteClusterStateService.class).forEach(Assert::assertNotNull);
+    }
+
     public void testRemotePublishConfigNodeJoinNonRemoteCluster() throws Exception {
         internalCluster().startClusterManagerOnlyNode();
         internalCluster().startDataOnlyNodes(2);
diff --git a/server/src/internalClusterTest/java/org/opensearch/gateway/remote/RemoteStatePublicationIT.java b/server/src/internalClusterTest/java/org/opensearch/gateway/remote/RemoteStatePublicationIT.java
index 578c922c80a0d..2409b5d0d0e45 100644
--- a/server/src/internalClusterTest/java/org/opensearch/gateway/remote/RemoteStatePublicationIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/gateway/remote/RemoteStatePublicationIT.java
@@ -215,7 +215,11 @@ public void testRemotePublicationDisableIfRemoteStateDisabled() {
         ensureStableCluster(5);
         ensureGreen(INDEX_NAME);
 
-        assertNull(internalCluster().getCurrentClusterManagerNodeInstance(RemoteClusterStateService.class));
+        RemoteClusterStateService remoteClusterStateService = internalCluster().getCurrentClusterManagerNodeInstance(
+            RemoteClusterStateService.class
+        );
+
+        assertFalse(remoteClusterStateService.isRemotePublicationEnabled());
     }
 
     public void testRemotePublicationDownloadStats() {
diff --git a/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteRestoreSnapshotIT.java b/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteRestoreSnapshotIT.java
index a0183e89bfce2..927dbf9995778 100644
--- a/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteRestoreSnapshotIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteRestoreSnapshotIT.java
@@ -9,6 +9,7 @@
 package org.opensearch.remotestore;
 
 import org.opensearch.action.DocWriteResponse;
+import org.opensearch.action.LatchedActionListener;
 import org.opensearch.action.admin.cluster.remotestore.restore.RestoreRemoteStoreRequest;
 import org.opensearch.action.admin.cluster.snapshots.create.CreateSnapshotResponse;
 import org.opensearch.action.admin.cluster.snapshots.get.GetSnapshotsRequest;
@@ -29,6 +30,7 @@
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.io.IOUtils;
+import org.opensearch.core.action.ActionListener;
 import org.opensearch.core.common.unit.ByteSizeUnit;
 import org.opensearch.core.index.Index;
 import org.opensearch.core.rest.RestStatus;
@@ -41,6 +43,7 @@
 import org.opensearch.indices.RemoteStoreSettings;
 import org.opensearch.indices.recovery.RecoveryState;
 import org.opensearch.indices.replication.common.ReplicationType;
+import org.opensearch.node.remotestore.RemoteStorePinnedTimestampService;
 import org.opensearch.repositories.RepositoriesService;
 import org.opensearch.repositories.Repository;
 import org.opensearch.repositories.RepositoryData;
@@ -62,8 +65,10 @@
 import java.util.Map;
 import java.util.Objects;
 import java.util.Optional;
+import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicLong;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
@@ -73,6 +78,7 @@
 import static org.opensearch.index.remote.RemoteStoreEnums.DataType.DATA;
 import static org.opensearch.index.remote.RemoteStoreEnums.DataType.METADATA;
 import static org.opensearch.indices.RemoteStoreSettings.CLUSTER_REMOTE_STORE_PATH_TYPE_SETTING;
+import static org.opensearch.snapshots.SnapshotsService.getPinningEntity;
 import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertAcked;
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.greaterThan;
@@ -753,17 +759,15 @@ public void testInvalidRestoreRequestScenarios() throws Exception {
         assertTrue(exception.getMessage().contains("cannot remove setting [index.remote_store.segment.repository]" + " on restore"));
     }
 
-    public void testCreateSnapshotV2() throws Exception {
+    public void testCreateSnapshotV2_Orphan_Timestamp_Cleanup() throws Exception {
         internalCluster().startClusterManagerOnlyNode(pinnedTimestampSettings());
         internalCluster().startDataOnlyNode(pinnedTimestampSettings());
         internalCluster().startDataOnlyNode(pinnedTimestampSettings());
         String indexName1 = "testindex1";
         String indexName2 = "testindex2";
-        String indexName3 = "testindex3";
         String snapshotRepoName = "test-create-snapshot-repo";
         String snapshotName1 = "test-create-snapshot1";
         Path absolutePath1 = randomRepoPath().toAbsolutePath();
-        logger.info("Snapshot Path [{}]", absolutePath1);
 
         Settings.Builder settings = Settings.builder()
             .put(FsRepository.LOCATION_SETTING.getKey(), absolutePath1)
@@ -787,27 +791,37 @@ public void testCreateSnapshotV2() throws Exception {
         indexDocuments(client, indexName2, numDocsInIndex2);
         ensureGreen(indexName1, indexName2);
 
+        // create an orphan timestamp related to this repo
+        RemoteStorePinnedTimestampService remoteStorePinnedTimestampService = internalCluster().getInstance(
+            RemoteStorePinnedTimestampService.class,
+            internalCluster().getClusterManagerName()
+        );
+        forceSyncPinnedTimestamps();
+
+        long pinnedTimestamp = System.currentTimeMillis();
+        final CountDownLatch latch = new CountDownLatch(1);
+        LatchedActionListener<Void> latchedActionListener = new LatchedActionListener<>(new ActionListener<>() {
+            @Override
+            public void onResponse(Void unused) {}
+
+            @Override
+            public void onFailure(Exception e) {}
+        }, latch);
+
+        remoteStorePinnedTimestampService.pinTimestamp(
+            pinnedTimestamp,
+            getPinningEntity(snapshotRepoName, "some_uuid"),
+            latchedActionListener
+        );
+        latch.await();
+
         SnapshotInfo snapshotInfo = createSnapshot(snapshotRepoName, snapshotName1, Collections.emptyList());
         assertThat(snapshotInfo.state(), equalTo(SnapshotState.SUCCESS));
         assertThat(snapshotInfo.successfulShards(), greaterThan(0));
         assertThat(snapshotInfo.successfulShards(), equalTo(snapshotInfo.totalShards()));
         assertThat(snapshotInfo.getPinnedTimestamp(), greaterThan(0L));
 
-        indexDocuments(client, indexName1, 10);
-        indexDocuments(client, indexName2, 20);
-
-        createIndex(indexName3, indexSettings);
-        indexDocuments(client, indexName3, 10);
-
-        String snapshotName2 = "test-create-snapshot2";
-
-        // verify response status if waitForCompletion is not true
-        RestStatus createSnapshotResponseStatus = client().admin()
-            .cluster()
-            .prepareCreateSnapshot(snapshotRepoName, snapshotName2)
-            .get()
-            .status();
-        assertEquals(RestStatus.ACCEPTED, createSnapshotResponseStatus);
+        waitUntil(() -> 1 == RemoteStorePinnedTimestampService.getPinnedEntities().size());
     }
 
     public void testMixedSnapshotCreationWithV2RepositorySetting() throws Exception {
@@ -879,7 +893,8 @@ public void testMixedSnapshotCreationWithV2RepositorySetting() throws Exception
         assertThat(snapshotInfo.successfulShards(), equalTo(snapshotInfo.totalShards()));
         assertThat(snapshotInfo.snapshotId().getName(), equalTo(snapshotName2));
         assertThat(snapshotInfo.getPinnedTimestamp(), greaterThan(0L));
-
+        forceSyncPinnedTimestamps();
+        assertEquals(RemoteStorePinnedTimestampService.getPinnedEntities().size(), 1);
     }
 
     public void testConcurrentSnapshotV2CreateOperation() throws InterruptedException, ExecutionException {
@@ -955,6 +970,8 @@ public void testConcurrentSnapshotV2CreateOperation() throws InterruptedExceptio
 
         RepositoryData repositoryData = repositoryDataPlainActionFuture.get();
         assertThat(repositoryData.getSnapshotIds().size(), greaterThanOrEqualTo(1));
+        forceSyncPinnedTimestamps();
+        assertEquals(RemoteStorePinnedTimestampService.getPinnedEntities().size(), repositoryData.getSnapshotIds().size());
     }
 
     public void testConcurrentSnapshotV2CreateOperation_MasterChange() throws Exception {
@@ -1017,13 +1034,92 @@ public void testConcurrentSnapshotV2CreateOperation_MasterChange() throws Except
             logger.info("Exception while creating new-snapshot", e);
         }
 
+        AtomicLong totalSnaps = new AtomicLong();
+
         // Validate that snapshot is present in repository data
         assertBusy(() -> {
             GetSnapshotsRequest request = new GetSnapshotsRequest(snapshotRepoName);
             GetSnapshotsResponse response2 = client().admin().cluster().getSnapshots(request).actionGet();
             assertThat(response2.getSnapshots().size(), greaterThanOrEqualTo(1));
+            totalSnaps.set(response2.getSnapshots().size());
+
         }, 30, TimeUnit.SECONDS);
         thread.join();
+        forceSyncPinnedTimestamps();
+        waitUntil(() -> {
+            this.forceSyncPinnedTimestamps();
+            return RemoteStorePinnedTimestampService.getPinnedEntities().size() == totalSnaps.intValue();
+        });
+    }
+
+    public void testCreateSnapshotV2() throws Exception {
+        internalCluster().startClusterManagerOnlyNode(pinnedTimestampSettings());
+        internalCluster().startDataOnlyNode(pinnedTimestampSettings());
+        internalCluster().startDataOnlyNode(pinnedTimestampSettings());
+        String indexName1 = "testindex1";
+        String indexName2 = "testindex2";
+        String indexName3 = "testindex3";
+        String snapshotRepoName = "test-create-snapshot-repo";
+        String snapshotName1 = "test-create-snapshot1";
+        Path absolutePath1 = randomRepoPath().toAbsolutePath();
+        logger.info("Snapshot Path [{}]", absolutePath1);
+
+        Settings.Builder settings = Settings.builder()
+            .put(FsRepository.LOCATION_SETTING.getKey(), absolutePath1)
+            .put(FsRepository.COMPRESS_SETTING.getKey(), randomBoolean())
+            .put(FsRepository.CHUNK_SIZE_SETTING.getKey(), randomIntBetween(100, 1000), ByteSizeUnit.BYTES)
+            .put(BlobStoreRepository.REMOTE_STORE_INDEX_SHALLOW_COPY.getKey(), true)
+            .put(BlobStoreRepository.SHALLOW_SNAPSHOT_V2.getKey(), true);
+
+        createRepository(snapshotRepoName, FsRepository.TYPE, settings);
+
+        Client client = client();
+        Settings indexSettings = getIndexSettings(20, 0).build();
+        createIndex(indexName1, indexSettings);
+
+        Settings indexSettings2 = getIndexSettings(15, 0).build();
+        createIndex(indexName2, indexSettings2);
+
+        final int numDocsInIndex1 = 10;
+        final int numDocsInIndex2 = 20;
+        indexDocuments(client, indexName1, numDocsInIndex1);
+        indexDocuments(client, indexName2, numDocsInIndex2);
+        ensureGreen(indexName1, indexName2);
+
+        SnapshotInfo snapshotInfo = createSnapshot(snapshotRepoName, snapshotName1, Collections.emptyList());
+        assertThat(snapshotInfo.state(), equalTo(SnapshotState.SUCCESS));
+        assertThat(snapshotInfo.successfulShards(), greaterThan(0));
+        assertThat(snapshotInfo.successfulShards(), equalTo(snapshotInfo.totalShards()));
+        assertThat(snapshotInfo.getPinnedTimestamp(), greaterThan(0L));
+
+        indexDocuments(client, indexName1, 10);
+        indexDocuments(client, indexName2, 20);
+
+        createIndex(indexName3, indexSettings);
+        indexDocuments(client, indexName3, 10);
+
+        String snapshotName2 = "test-create-snapshot2";
+
+        // verify response status if waitForCompletion is not true
+        RestStatus createSnapshotResponseStatus = client().admin()
+            .cluster()
+            .prepareCreateSnapshot(snapshotRepoName, snapshotName2)
+            .get()
+            .status();
+        assertEquals(RestStatus.ACCEPTED, createSnapshotResponseStatus);
+        forceSyncPinnedTimestamps();
+        assertEquals(2, RemoteStorePinnedTimestampService.getPinnedEntities().size());
+    }
+
+    public void forceSyncPinnedTimestamps() {
+        // for all nodes , run forceSyncPinnedTimestamps()
+        for (String node : internalCluster().getNodeNames()) {
+            RemoteStorePinnedTimestampService remoteStorePinnedTimestampService = internalCluster().getInstance(
+                RemoteStorePinnedTimestampService.class,
+                node
+            );
+            remoteStorePinnedTimestampService.forceSyncPinnedTimestamps();
+        }
     }
 
     public void testCreateSnapshotV2WithRedIndex() throws Exception {
diff --git a/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStorePinnedTimestampsGarbageCollectionIT.java b/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStorePinnedTimestampsGarbageCollectionIT.java
index 0a2668c60d3bd..08ece7df457cc 100644
--- a/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStorePinnedTimestampsGarbageCollectionIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStorePinnedTimestampsGarbageCollectionIT.java
@@ -8,6 +8,7 @@
 
 package org.opensearch.remotestore;
 
+import org.opensearch.action.support.IndicesOptions;
 import org.opensearch.common.blobstore.BlobPath;
 import org.opensearch.common.collect.Tuple;
 import org.opensearch.common.settings.Settings;
@@ -32,6 +33,7 @@
 import static org.opensearch.index.remote.RemoteStoreEnums.DataCategory.TRANSLOG;
 import static org.opensearch.index.remote.RemoteStoreEnums.DataType.DATA;
 import static org.opensearch.index.remote.RemoteStoreEnums.DataType.METADATA;
+import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertNoFailures;
 
 @OpenSearchIntegTestCase.ClusterScope(scope = OpenSearchIntegTestCase.Scope.TEST, numDataNodes = 0)
 public class RemoteStorePinnedTimestampsGarbageCollectionIT extends RemoteStoreBaseIntegTestCase {
@@ -288,6 +290,79 @@ public void testLiveIndexWithPinnedTimestamps() throws Exception {
         });
     }
 
+    public void testLiveIndexWithPinnedTimestampsMultiplePrimaryTerms() throws Exception {
+        prepareCluster(1, 2, Settings.EMPTY);
+        Settings indexSettings = Settings.builder()
+            .put(remoteStoreIndexSettings(1, 1))
+            .put(INDEX_REMOTE_TRANSLOG_KEEP_EXTRA_GEN_SETTING.getKey(), 3)
+            .build();
+        createIndex(INDEX_NAME, indexSettings);
+        ensureYellowAndNoInitializingShards(INDEX_NAME);
+        ensureGreen(INDEX_NAME);
+
+        RemoteStoreSettings.setPinnedTimestampsLookbackInterval(TimeValue.ZERO);
+
+        RemoteStorePinnedTimestampService remoteStorePinnedTimestampService = internalCluster().getInstance(
+            RemoteStorePinnedTimestampService.class,
+            primaryNodeName(INDEX_NAME)
+        );
+
+        remoteStorePinnedTimestampService.rescheduleAsyncUpdatePinnedTimestampTask(TimeValue.timeValueSeconds(1));
+
+        int numDocs = randomIntBetween(5, 10);
+        for (int i = 0; i < numDocs; i++) {
+            keepPinnedTimestampSchedulerUpdated();
+            indexSingleDoc(INDEX_NAME, true);
+            if (i == 2) {
+                RemoteStoreSettings.setPinnedTimestampsLookbackInterval(TimeValue.timeValueMinutes(1));
+                remoteStorePinnedTimestampService.pinTimestamp(System.currentTimeMillis(), "xyz", noOpActionListener);
+                RemoteStoreSettings.setPinnedTimestampsLookbackInterval(TimeValue.ZERO);
+            }
+        }
+
+        ingestDocs();
+
+        internalCluster().restartNode(primaryNodeName(INDEX_NAME));
+        ensureGreen(INDEX_NAME);
+
+        ingestDocs();
+
+        String translogPathFixedPrefix = RemoteStoreSettings.CLUSTER_REMOTE_STORE_TRANSLOG_PATH_PREFIX.get(getNodeSettings());
+        String shardDataPath = getShardLevelBlobPath(
+            client(),
+            INDEX_NAME,
+            BlobPath.cleanPath(),
+            "0",
+            TRANSLOG,
+            DATA,
+            translogPathFixedPrefix
+        ).buildAsString();
+        Path translogDataPath = Path.of(translogRepoPath + "/" + shardDataPath + "/1");
+
+        assertBusy(() -> {
+            List<Path> dataFiles = Files.list(translogDataPath).collect(Collectors.toList());
+            assertFalse(dataFiles.isEmpty());
+        });
+    }
+
+    private void ingestDocs() {
+        int numDocs = randomIntBetween(15, 20);
+        for (int i = 0; i < numDocs; i++) {
+            indexSingleDoc(INDEX_NAME, false);
+        }
+
+        assertNoFailures(client().admin().indices().prepareRefresh(INDEX_NAME).setIndicesOptions(IndicesOptions.lenientExpandOpen()).get());
+        flushAndRefresh(INDEX_NAME);
+
+        int numDocsPostFailover = randomIntBetween(15, 20);
+        for (int i = 0; i < numDocsPostFailover; i++) {
+            indexSingleDoc(INDEX_NAME, false);
+        }
+
+        flushAndRefresh(INDEX_NAME);
+        assertNoFailures(client().admin().indices().prepareRefresh(INDEX_NAME).setIndicesOptions(IndicesOptions.lenientExpandOpen()).get());
+    }
+
     public void testIndexDeletionNoPinnedTimestamps() throws Exception {
         prepareCluster(1, 1, Settings.EMPTY);
         Settings indexSettings = Settings.builder()
diff --git a/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStorePinnedTimestampsIT.java b/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStorePinnedTimestampsIT.java
index 2fcda8c2d2f27..3e1127e0ce240 100644
--- a/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStorePinnedTimestampsIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStorePinnedTimestampsIT.java
@@ -9,6 +9,8 @@
 package org.opensearch.remotestore;
 
 import org.opensearch.action.LatchedActionListener;
+import org.opensearch.action.admin.cluster.node.stats.NodeStats;
+import org.opensearch.action.admin.cluster.node.stats.NodesStatsResponse;
 import org.opensearch.common.collect.Tuple;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.unit.TimeValue;
@@ -17,9 +19,14 @@
 import org.opensearch.node.remotestore.RemoteStorePinnedTimestampService;
 import org.opensearch.test.OpenSearchIntegTestCase;
 
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
 import java.util.Set;
 import java.util.concurrent.CountDownLatch;
 
+import static org.opensearch.action.admin.cluster.node.stats.NodesStatsRequest.Metric.REMOTE_STORE;
+
 @OpenSearchIntegTestCase.ClusterScope(scope = OpenSearchIntegTestCase.Scope.TEST, numDataNodes = 0)
 public class RemoteStorePinnedTimestampsIT extends RemoteStoreBaseIntegTestCase {
     static final String INDEX_NAME = "remote-store-test-idx-1";
@@ -72,6 +79,11 @@ public void testTimestampPinUnpin() throws Exception {
             Tuple<Long, Set<Long>> pinnedTimestampWithFetchTimestamp_2 = RemoteStorePinnedTimestampService.getPinnedTimestamps();
             long lastFetchTimestamp_2 = pinnedTimestampWithFetchTimestamp_2.v1();
             assertTrue(lastFetchTimestamp_2 != -1);
+            Map<String, List<Long>> pinnedEntities = RemoteStorePinnedTimestampService.getPinnedEntities();
+            assertEquals(3, pinnedEntities.size());
+            assertEquals(Set.of("ss2", "ss3", "ss4"), pinnedEntities.keySet());
+            assertEquals(pinnedEntities.get("ss2").size(), 1);
+            assertEquals(Optional.of(timestamp1).get(), pinnedEntities.get("ss2").get(0));
             assertEquals(Set.of(timestamp1, timestamp2, timestamp3), pinnedTimestampWithFetchTimestamp_2.v2());
         });
 
@@ -99,10 +111,14 @@ public void onFailure(Exception e) {
         // Adding different entity to already pinned timestamp
         remoteStorePinnedTimestampService.pinTimestamp(timestamp3, "ss5", noOpActionListener);
 
-        remoteStorePinnedTimestampService.rescheduleAsyncUpdatePinnedTimestampTask(TimeValue.timeValueSeconds(1));
+        remoteStorePinnedTimestampService.forceSyncPinnedTimestamps();
 
         assertBusy(() -> {
             Tuple<Long, Set<Long>> pinnedTimestampWithFetchTimestamp_3 = RemoteStorePinnedTimestampService.getPinnedTimestamps();
+            Map<String, List<Long>> pinnedEntities = RemoteStorePinnedTimestampService.getPinnedEntities();
+            assertEquals(3, pinnedEntities.size());
+            assertEquals(pinnedEntities.get("ss5").size(), 1);
+            assertEquals(Optional.of(timestamp3).get(), pinnedEntities.get("ss5").get(0));
             long lastFetchTimestamp_3 = pinnedTimestampWithFetchTimestamp_3.v1();
             assertTrue(lastFetchTimestamp_3 != -1);
             assertEquals(Set.of(timestamp1, timestamp3), pinnedTimestampWithFetchTimestamp_3.v2());
@@ -180,4 +196,41 @@ public void onFailure(Exception e) {
         assertBusy(() -> assertEquals(Set.of(timestamp2, timestamp3), RemoteStorePinnedTimestampService.getPinnedTimestamps().v2()));
         remoteStorePinnedTimestampService.rescheduleAsyncUpdatePinnedTimestampTask(TimeValue.timeValueMinutes(3));
     }
+
+    public void testLastSuccessfulFetchOfPinnedTimestampsPresentInNodeStats() throws Exception {
+        logger.info("Starting up cluster manager");
+        logger.info("cluster.remote_store.pinned_timestamps.enabled set to true");
+        logger.info("cluster.remote_store.pinned_timestamps.scheduler_interval set to minimum value of 1minute");
+        Settings pinnedTimestampEnabledSettings = Settings.builder()
+            .put(RemoteStoreSettings.CLUSTER_REMOTE_STORE_PINNED_TIMESTAMP_ENABLED.getKey(), true)
+            .put(RemoteStoreSettings.CLUSTER_REMOTE_STORE_PINNED_TIMESTAMP_SCHEDULER_INTERVAL.getKey(), "1m")
+            .build();
+        internalCluster().startClusterManagerOnlyNode(pinnedTimestampEnabledSettings);
+        String remoteNodeName = internalCluster().startDataOnlyNodes(1, pinnedTimestampEnabledSettings).get(0);
+        ensureStableCluster(2);
+        RemoteStorePinnedTimestampService remoteStorePinnedTimestampService = internalCluster().getInstance(
+            RemoteStorePinnedTimestampService.class,
+            remoteNodeName
+        );
+
+        remoteStorePinnedTimestampService.rescheduleAsyncUpdatePinnedTimestampTask(TimeValue.timeValueSeconds(1));
+
+        assertBusy(() -> {
+            long lastSuccessfulFetchOfPinnedTimestamps = RemoteStorePinnedTimestampService.getPinnedTimestamps().v1();
+            assertTrue(lastSuccessfulFetchOfPinnedTimestamps > 0L);
+            NodesStatsResponse nodesStatsResponse = internalCluster().client()
+                .admin()
+                .cluster()
+                .prepareNodesStats()
+                .addMetric(REMOTE_STORE.metricName())
+                .execute()
+                .actionGet();
+            for (NodeStats nodeStats : nodesStatsResponse.getNodes()) {
+                long lastRecordedFetch = nodeStats.getRemoteStoreNodeStats().getLastSuccessfulFetchOfPinnedTimestamps();
+                assertTrue(lastRecordedFetch >= lastSuccessfulFetchOfPinnedTimestamps);
+            }
+        });
+
+        remoteStorePinnedTimestampService.rescheduleAsyncUpdatePinnedTimestampTask(TimeValue.timeValueMinutes(3));
+    }
 }
diff --git a/server/src/internalClusterTest/java/org/opensearch/snapshots/DeleteSnapshotV2IT.java b/server/src/internalClusterTest/java/org/opensearch/snapshots/DeleteSnapshotV2IT.java
index c4e3a478c8540..7b2ad2bccd2b1 100644
--- a/server/src/internalClusterTest/java/org/opensearch/snapshots/DeleteSnapshotV2IT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/snapshots/DeleteSnapshotV2IT.java
@@ -30,6 +30,7 @@
 import java.util.concurrent.TimeUnit;
 import java.util.stream.Collectors;
 
+import static org.opensearch.index.IndexSettings.INDEX_REMOTE_TRANSLOG_KEEP_EXTRA_GEN_SETTING;
 import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertAcked;
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.greaterThan;
@@ -312,6 +313,107 @@ public void testRemoteStoreCleanupForDeletedIndexForSnapshotV2MultipleSnapshots(
         // translogPostDeletionOfSnapshot1.size()), 60, TimeUnit.SECONDS);
     }
 
+    public void testRemoteStoreCleanupMultiplePrimaryOnSnapshotDeletion() throws Exception {
+        disableRepoConsistencyCheck("Remote store repository is being used in the test");
+        final Path remoteStoreRepoPath = randomRepoPath();
+        Settings settings = remoteStoreClusterSettings(REMOTE_REPO_NAME, remoteStoreRepoPath);
+        settings = Settings.builder()
+            .put(settings)
+            .put(RemoteStoreSettings.CLUSTER_REMOTE_STORE_PINNED_TIMESTAMP_ENABLED.getKey(), true)
+            .put(RemoteStoreSettings.CLUSTER_REMOTE_STORE_PATH_TYPE_SETTING.getKey(), RemoteStoreEnums.PathType.FIXED.toString())
+            .build();
+        String clusterManagerName = internalCluster().startClusterManagerOnlyNode(settings);
+        internalCluster().startDataOnlyNodes(3, settings);
+        final Client clusterManagerClient = internalCluster().clusterManagerClient();
+        ensureStableCluster(4);
+
+        RemoteStorePinnedTimestampService remoteStorePinnedTimestampService = internalCluster().getInstance(
+            RemoteStorePinnedTimestampService.class,
+            clusterManagerName
+        );
+        remoteStorePinnedTimestampService.rescheduleAsyncUpdatePinnedTimestampTask(TimeValue.timeValueSeconds(1));
+        RemoteStoreSettings.setPinnedTimestampsLookbackInterval(TimeValue.ZERO);
+
+        final String snapshotRepoName = "snapshot-repo-name";
+        final Path snapshotRepoPath = randomRepoPath();
+        createRepository(snapshotRepoName, "mock", snapshotRepoSettingsForShallowV2(snapshotRepoPath));
+
+        final String remoteStoreEnabledIndexName = "remote-index-1";
+        final Settings remoteStoreEnabledIndexSettings = Settings.builder()
+            .put(getRemoteStoreBackedIndexSettings())
+            .put(INDEX_REMOTE_TRANSLOG_KEEP_EXTRA_GEN_SETTING.getKey(), 2)
+            .build();
+        createIndex(remoteStoreEnabledIndexName, remoteStoreEnabledIndexSettings);
+        ensureGreen(remoteStoreEnabledIndexName);
+
+        // Create 2 snapshots for primary term 1
+        keepPinnedTimestampSchedulerUpdated();
+        indexRandomDocs(remoteStoreEnabledIndexName, 5);
+        createSnapshot(snapshotRepoName, "snap1");
+        keepPinnedTimestampSchedulerUpdated();
+        indexRandomDocs(remoteStoreEnabledIndexName, 5);
+        createSnapshot(snapshotRepoName, "snap2");
+
+        // Restart current primary to change the primary term
+        internalCluster().restartNode(primaryNodeName(remoteStoreEnabledIndexName));
+        ensureGreen(remoteStoreEnabledIndexName);
+
+        // Create 2 snapshots for primary term 2
+        keepPinnedTimestampSchedulerUpdated();
+        indexRandomDocs(remoteStoreEnabledIndexName, 5);
+        createSnapshot(snapshotRepoName, "snap3");
+        keepPinnedTimestampSchedulerUpdated();
+        indexRandomDocs(remoteStoreEnabledIndexName, 5);
+        createSnapshot(snapshotRepoName, "snap4");
+
+        String indexUUID = client().admin()
+            .indices()
+            .prepareGetSettings(remoteStoreEnabledIndexName)
+            .get()
+            .getSetting(remoteStoreEnabledIndexName, IndexMetadata.SETTING_INDEX_UUID);
+
+        Path indexPath = Path.of(String.valueOf(remoteStoreRepoPath), indexUUID);
+        Path shardPath = Path.of(String.valueOf(indexPath), "0");
+        Path translogPath = Path.of(String.valueOf(shardPath), "translog", "data", "1");
+
+        // Deleting snap1 will still keep files in primary term 1 due to snap2
+        deleteSnapshot(clusterManagerClient, snapshotRepoName, "snap1");
+        assertTrue(RemoteStoreBaseIntegTestCase.getFileCount(translogPath) > 0);
+
+        // Deleting snap2 will not remove primary term 1 as we need to trigger trimUnreferencedReaders once
+        deleteSnapshot(clusterManagerClient, snapshotRepoName, "snap2");
+        assertTrue(RemoteStoreBaseIntegTestCase.getFileCount(translogPath) > 0);
+
+        // Index a doc to trigger trimUnreferencedReaders
+        RemoteStoreSettings.setPinnedTimestampsLookbackInterval(TimeValue.ZERO);
+        keepPinnedTimestampSchedulerUpdated();
+        indexRandomDocs(remoteStoreEnabledIndexName, 5);
+
+        assertBusy(() -> assertFalse(Files.exists(translogPath)), 30, TimeUnit.SECONDS);
+    }
+
+    private void createSnapshot(String repoName, String snapshotName) {
+        CreateSnapshotResponse createSnapshotResponse = client().admin()
+            .cluster()
+            .prepareCreateSnapshot(repoName, snapshotName)
+            .setWaitForCompletion(true)
+            .get();
+        SnapshotInfo snapshotInfo = createSnapshotResponse.getSnapshotInfo();
+
+        assertThat(snapshotInfo.state(), equalTo(SnapshotState.SUCCESS));
+        assertThat(snapshotInfo.successfulShards(), greaterThan(0));
+        assertThat(snapshotInfo.successfulShards(), equalTo(snapshotInfo.totalShards()));
+        assertThat(snapshotInfo.snapshotId().getName(), equalTo(snapshotName));
+    }
+
+    private void deleteSnapshot(Client clusterManagerClient, String repoName, String snapshotName) {
+        AcknowledgedResponse deleteSnapshotResponse = clusterManagerClient.admin()
+            .cluster()
+            .prepareDeleteSnapshot(repoName, snapshotName)
+            .get();
+        assertAcked(deleteSnapshotResponse);
+    }
+
     private Settings snapshotV2Settings(Path remoteStoreRepoPath) {
         Settings settings = Settings.builder()
             .put(remoteStoreClusterSettings(REMOTE_REPO_NAME, remoteStoreRepoPath))
diff --git a/server/src/internalClusterTest/java/org/opensearch/snapshots/SnapshotStatusApisIT.java b/server/src/internalClusterTest/java/org/opensearch/snapshots/SnapshotStatusApisIT.java
index c3214022df663..8b6869aa1d81a 100644
--- a/server/src/internalClusterTest/java/org/opensearch/snapshots/SnapshotStatusApisIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/snapshots/SnapshotStatusApisIT.java
@@ -116,7 +116,7 @@ public void testStatusApiConsistency() {
         assertEquals(snapshotStatus.getStats().getTime(), snapshotInfo.endTime() - snapshotInfo.startTime());
     }
 
-    public void testStatusAPICallForShallowCopySnapshot() {
+    public void testStatusAPICallForShallowCopySnapshot() throws Exception {
         disableRepoConsistencyCheck("Remote store repository is being used for the test");
         internalCluster().startClusterManagerOnlyNode();
         internalCluster().startDataOnlyNode();
@@ -136,15 +136,24 @@ public void testStatusAPICallForShallowCopySnapshot() {
         final String snapshot = "snapshot";
         createFullSnapshot(snapshotRepoName, snapshot);
 
-        final SnapshotStatus snapshotStatus = getSnapshotStatus(snapshotRepoName, snapshot);
-        assertThat(snapshotStatus.getState(), is(SnapshotsInProgress.State.SUCCESS));
+        assertBusy(() -> {
+            final SnapshotStatus snapshotStatus = client().admin()
+                .cluster()
+                .prepareSnapshotStatus(snapshotRepoName)
+                .setSnapshots(snapshot)
+                .execute()
+                .actionGet()
+                .getSnapshots()
+                .get(0);
+            assertThat(snapshotStatus.getState(), is(SnapshotsInProgress.State.SUCCESS));
 
-        final SnapshotIndexShardStatus snapshotShardState = stateFirstShard(snapshotStatus, indexName);
-        assertThat(snapshotShardState.getStage(), is(SnapshotIndexShardStage.DONE));
-        assertThat(snapshotShardState.getStats().getTotalFileCount(), greaterThan(0));
-        assertThat(snapshotShardState.getStats().getTotalSize(), greaterThan(0L));
-        assertThat(snapshotShardState.getStats().getIncrementalFileCount(), greaterThan(0));
-        assertThat(snapshotShardState.getStats().getIncrementalSize(), greaterThan(0L));
+            final SnapshotIndexShardStatus snapshotShardState = stateFirstShard(snapshotStatus, indexName);
+            assertThat(snapshotShardState.getStage(), is(SnapshotIndexShardStage.DONE));
+            assertThat(snapshotShardState.getStats().getTotalFileCount(), greaterThan(0));
+            assertThat(snapshotShardState.getStats().getTotalSize(), greaterThan(0L));
+            assertThat(snapshotShardState.getStats().getIncrementalFileCount(), greaterThan(0));
+            assertThat(snapshotShardState.getStats().getIncrementalSize(), greaterThan(0L));
+        }, 20, TimeUnit.SECONDS);
     }
 
     public void testStatusAPICallInProgressSnapshot() throws Exception {
@@ -193,7 +202,7 @@ public void testExceptionOnMissingSnapBlob() throws IOException {
         );
     }
 
-    public void testExceptionOnMissingShardLevelSnapBlob() throws IOException {
+    public void testExceptionOnMissingShardLevelSnapBlob() throws Exception {
         disableRepoConsistencyCheck("This test intentionally corrupts the repository");
 
         final Path repoPath = randomRepoPath();
@@ -216,11 +225,12 @@ public void testExceptionOnMissingShardLevelSnapBlob() throws IOException {
             repoPath.resolve(resolvePath(indexId, "0"))
                 .resolve(BlobStoreRepository.SNAPSHOT_PREFIX + snapshotInfo.snapshotId().getUUID() + ".dat")
         );
-
-        expectThrows(
-            SnapshotMissingException.class,
-            () -> client().admin().cluster().prepareSnapshotStatus("test-repo").setSnapshots("test-snap").execute().actionGet()
-        );
+        assertBusy(() -> {
+            expectThrows(
+                SnapshotMissingException.class,
+                () -> client().admin().cluster().prepareSnapshotStatus("test-repo").setSnapshots("test-snap").execute().actionGet()
+            );
+        }, 20, TimeUnit.SECONDS);
     }
 
     public void testGetSnapshotsWithoutIndices() throws Exception {
diff --git a/server/src/main/java/org/opensearch/OpenSearchServerException.java b/server/src/main/java/org/opensearch/OpenSearchServerException.java
index b0ab62259d5c0..0ee3debb4819a 100644
--- a/server/src/main/java/org/opensearch/OpenSearchServerException.java
+++ b/server/src/main/java/org/opensearch/OpenSearchServerException.java
@@ -14,6 +14,7 @@
 import static org.opensearch.Version.V_2_10_0;
 import static org.opensearch.Version.V_2_13_0;
 import static org.opensearch.Version.V_2_17_0;
+import static org.opensearch.Version.V_2_18_0;
 import static org.opensearch.Version.V_2_1_0;
 import static org.opensearch.Version.V_2_4_0;
 import static org.opensearch.Version.V_2_5_0;
@@ -1210,6 +1211,14 @@ public static void registerExceptions() {
                 V_2_17_0
             )
         );
+        registerExceptionHandle(
+            new OpenSearchExceptionHandle(
+                org.opensearch.common.breaker.ResponseLimitBreachedException.class,
+                org.opensearch.common.breaker.ResponseLimitBreachedException::new,
+                175,
+                V_2_18_0
+            )
+        );
         registerExceptionHandle(
             new OpenSearchExceptionHandle(
                 org.opensearch.cluster.block.IndexCreateBlockException.class,
diff --git a/server/src/main/java/org/opensearch/action/ActionModule.java b/server/src/main/java/org/opensearch/action/ActionModule.java
index 3fe0f1dc7cb83..98bcd6ba9c3f8 100644
--- a/server/src/main/java/org/opensearch/action/ActionModule.java
+++ b/server/src/main/java/org/opensearch/action/ActionModule.java
@@ -300,6 +300,7 @@
 import org.opensearch.cluster.node.DiscoveryNodes;
 import org.opensearch.common.NamedRegistry;
 import org.opensearch.common.annotation.PublicApi;
+import org.opensearch.common.breaker.ResponseLimitSettings;
 import org.opensearch.common.inject.AbstractModule;
 import org.opensearch.common.inject.TypeLiteral;
 import org.opensearch.common.inject.multibindings.MapBinder;
@@ -461,6 +462,9 @@
 import org.opensearch.rest.action.ingest.RestGetPipelineAction;
 import org.opensearch.rest.action.ingest.RestPutPipelineAction;
 import org.opensearch.rest.action.ingest.RestSimulatePipelineAction;
+import org.opensearch.rest.action.list.AbstractListAction;
+import org.opensearch.rest.action.list.RestIndicesListAction;
+import org.opensearch.rest.action.list.RestListAction;
 import org.opensearch.rest.action.search.RestClearScrollAction;
 import org.opensearch.rest.action.search.RestCountAction;
 import org.opensearch.rest.action.search.RestCreatePitAction;
@@ -528,6 +532,7 @@ public class ActionModule extends AbstractModule {
     private final RequestValidators<IndicesAliasesRequest> indicesAliasesRequestRequestValidators;
     private final ThreadPool threadPool;
     private final ExtensionsManager extensionsManager;
+    private final ResponseLimitSettings responseLimitSettings;
 
     public ActionModule(
         Settings settings,
@@ -580,6 +585,7 @@ public ActionModule(
         );
 
         restController = new RestController(headers, restWrapper, nodeClient, circuitBreakerService, usageService);
+        responseLimitSettings = new ResponseLimitSettings(clusterSettings, settings);
     }
 
     public Map<String, ActionHandler<?, ?>> getActions() {
@@ -802,9 +808,14 @@ private ActionFilters setupActionFilters(List<ActionPlugin> actionPlugins) {
 
     public void initRestHandlers(Supplier<DiscoveryNodes> nodesInCluster) {
         List<AbstractCatAction> catActions = new ArrayList<>();
+        List<AbstractListAction> listActions = new ArrayList<>();
         Consumer<RestHandler> registerHandler = handler -> {
             if (handler instanceof AbstractCatAction) {
-                catActions.add((AbstractCatAction) handler);
+                if (handler instanceof AbstractListAction && ((AbstractListAction) handler).isActionPaginated()) {
+                    listActions.add((AbstractListAction) handler);
+                } else {
+                    catActions.add((AbstractCatAction) handler);
+                }
             }
             restController.registerHandler(handler);
         };
@@ -960,8 +971,8 @@ public void initRestHandlers(Supplier<DiscoveryNodes> nodesInCluster) {
         registerHandler.accept(new RestClusterManagerAction());
         registerHandler.accept(new RestNodesAction());
         registerHandler.accept(new RestTasksAction(nodesInCluster));
-        registerHandler.accept(new RestIndicesAction());
-        registerHandler.accept(new RestSegmentsAction());
+        registerHandler.accept(new RestIndicesAction(responseLimitSettings));
+        registerHandler.accept(new RestSegmentsAction(responseLimitSettings));
         // Fully qualified to prevent interference with rest.action.count.RestCountAction
         registerHandler.accept(new org.opensearch.rest.action.cat.RestCountAction());
         // Fully qualified to prevent interference with rest.action.indices.RestRecoveryAction
@@ -980,6 +991,9 @@ public void initRestHandlers(Supplier<DiscoveryNodes> nodesInCluster) {
         }
         registerHandler.accept(new RestTemplatesAction());
 
+        // LIST API
+        registerHandler.accept(new RestIndicesListAction(responseLimitSettings));
+
         // Point in time API
         registerHandler.accept(new RestCreatePitAction());
         registerHandler.accept(new RestDeletePitAction());
@@ -1011,6 +1025,7 @@ public void initRestHandlers(Supplier<DiscoveryNodes> nodesInCluster) {
             }
         }
         registerHandler.accept(new RestCatAction(catActions));
+        registerHandler.accept(new RestListAction(listActions));
         registerHandler.accept(new RestDecommissionAction());
         registerHandler.accept(new RestGetDecommissionStateAction());
         registerHandler.accept(new RestRemoteStoreStatsAction());
@@ -1048,6 +1063,8 @@ protected void configure() {
 
         // register dynamic ActionType -> transportAction Map used by NodeClient
         bind(DynamicActionRegistry.class).toInstance(dynamicActionRegistry);
+
+        bind(ResponseLimitSettings.class).toInstance(responseLimitSettings);
     }
 
     public ActionFilters getActionFilters() {
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/NodeStats.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/NodeStats.java
index 0917a0baff1ab..eb79e3403a25c 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/NodeStats.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/NodeStats.java
@@ -59,6 +59,7 @@
 import org.opensearch.monitor.process.ProcessStats;
 import org.opensearch.node.AdaptiveSelectionStats;
 import org.opensearch.node.NodesResourceUsageStats;
+import org.opensearch.node.remotestore.RemoteStoreNodeStats;
 import org.opensearch.ratelimitting.admissioncontrol.stats.AdmissionControlStats;
 import org.opensearch.repositories.RepositoriesStats;
 import org.opensearch.script.ScriptCacheStats;
@@ -162,6 +163,9 @@ public class NodeStats extends BaseNodeResponse implements ToXContentFragment {
     @Nullable
     private NodeCacheStats nodeCacheStats;
 
+    @Nullable
+    private RemoteStoreNodeStats remoteStoreNodeStats;
+
     public NodeStats(StreamInput in) throws IOException {
         super(in);
         timestamp = in.readVLong();
@@ -243,6 +247,11 @@ public NodeStats(StreamInput in) throws IOException {
         } else {
             nodeCacheStats = null;
         }
+        if (in.getVersion().onOrAfter(Version.V_2_18_0)) {
+            remoteStoreNodeStats = in.readOptionalWriteable(RemoteStoreNodeStats::new);
+        } else {
+            remoteStoreNodeStats = null;
+        }
     }
 
     public NodeStats(
@@ -274,7 +283,8 @@ public NodeStats(
         @Nullable SegmentReplicationRejectionStats segmentReplicationRejectionStats,
         @Nullable RepositoriesStats repositoriesStats,
         @Nullable AdmissionControlStats admissionControlStats,
-        @Nullable NodeCacheStats nodeCacheStats
+        @Nullable NodeCacheStats nodeCacheStats,
+        @Nullable RemoteStoreNodeStats remoteStoreNodeStats
     ) {
         super(node);
         this.timestamp = timestamp;
@@ -305,6 +315,7 @@ public NodeStats(
         this.repositoriesStats = repositoriesStats;
         this.admissionControlStats = admissionControlStats;
         this.nodeCacheStats = nodeCacheStats;
+        this.remoteStoreNodeStats = remoteStoreNodeStats;
     }
 
     public long getTimestamp() {
@@ -467,6 +478,11 @@ public NodeCacheStats getNodeCacheStats() {
         return nodeCacheStats;
     }
 
+    @Nullable
+    public RemoteStoreNodeStats getRemoteStoreNodeStats() {
+        return remoteStoreNodeStats;
+    }
+
     @Override
     public void writeTo(StreamOutput out) throws IOException {
         super.writeTo(out);
@@ -525,6 +541,9 @@ public void writeTo(StreamOutput out) throws IOException {
         if (out.getVersion().onOrAfter(Version.V_2_14_0)) {
             out.writeOptionalWriteable(nodeCacheStats);
         }
+        if (out.getVersion().onOrAfter(Version.V_2_18_0)) {
+            out.writeOptionalWriteable(remoteStoreNodeStats);
+        }
     }
 
     @Override
@@ -631,6 +650,9 @@ public XContentBuilder toXContent(XContentBuilder builder, Params params) throws
         if (getNodeCacheStats() != null) {
             getNodeCacheStats().toXContent(builder, params);
         }
+        if (getRemoteStoreNodeStats() != null) {
+            getRemoteStoreNodeStats().toXContent(builder, params);
+        }
         return builder;
     }
 }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/NodesStatsRequest.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/NodesStatsRequest.java
index f1f9f93afdad2..a5b00ed82d3cb 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/NodesStatsRequest.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/NodesStatsRequest.java
@@ -220,7 +220,8 @@ public enum Metric {
         SEGMENT_REPLICATION_BACKPRESSURE("segment_replication_backpressure"),
         REPOSITORIES("repositories"),
         ADMISSION_CONTROL("admission_control"),
-        CACHE_STATS("caches");
+        CACHE_STATS("caches"),
+        REMOTE_STORE("remote_store");
 
         private String metricName;
 
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/TransportNodesStatsAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/TransportNodesStatsAction.java
index 2c808adc97c7a..a98d245af872b 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/TransportNodesStatsAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/TransportNodesStatsAction.java
@@ -129,7 +129,8 @@ protected NodeStats nodeOperation(NodeStatsRequest nodeStatsRequest) {
             NodesStatsRequest.Metric.SEGMENT_REPLICATION_BACKPRESSURE.containedIn(metrics),
             NodesStatsRequest.Metric.REPOSITORIES.containedIn(metrics),
             NodesStatsRequest.Metric.ADMISSION_CONTROL.containedIn(metrics),
-            NodesStatsRequest.Metric.CACHE_STATS.containedIn(metrics)
+            NodesStatsRequest.Metric.CACHE_STATS.containedIn(metrics),
+            NodesStatsRequest.Metric.REMOTE_STORE.containedIn(metrics)
         );
     }
 
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/shards/CatShardsRequest.java b/server/src/main/java/org/opensearch/action/admin/cluster/shards/CatShardsRequest.java
index 49299777db8ae..76aa25b9a96b5 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/shards/CatShardsRequest.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/shards/CatShardsRequest.java
@@ -27,11 +27,13 @@ public class CatShardsRequest extends ClusterManagerNodeReadRequest<CatShardsReq
 
     private String[] indices;
     private TimeValue cancelAfterTimeInterval;
+    private boolean requestLimitCheckSupported;
 
     public CatShardsRequest() {}
 
     public CatShardsRequest(StreamInput in) throws IOException {
         super(in);
+        this.requestLimitCheckSupported = false;
     }
 
     @Override
@@ -55,6 +57,14 @@ public TimeValue getCancelAfterTimeInterval() {
         return this.cancelAfterTimeInterval;
     }
 
+    public void setRequestLimitCheckSupported(final boolean requestLimitCheckSupported) {
+        this.requestLimitCheckSupported = requestLimitCheckSupported;
+    }
+
+    public boolean isRequestLimitCheckSupported() {
+        return this.requestLimitCheckSupported;
+    }
+
     @Override
     public ClusterAdminTask createTask(long id, String type, String action, TaskId parentTaskId, Map<String, String> headers) {
         return new ClusterAdminTask(id, type, action, parentTaskId, headers, this.cancelAfterTimeInterval);
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/shards/TransportCatShardsAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/shards/TransportCatShardsAction.java
index 224d3cbc5f10a..6b073a16f7d28 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/shards/TransportCatShardsAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/shards/TransportCatShardsAction.java
@@ -16,6 +16,8 @@
 import org.opensearch.action.support.HandledTransportAction;
 import org.opensearch.action.support.TimeoutTaskCancellationUtility;
 import org.opensearch.client.node.NodeClient;
+import org.opensearch.common.breaker.ResponseLimitBreachedException;
+import org.opensearch.common.breaker.ResponseLimitSettings;
 import org.opensearch.common.inject.Inject;
 import org.opensearch.core.action.ActionListener;
 import org.opensearch.core.action.NotifyOnceListener;
@@ -23,6 +25,10 @@
 import org.opensearch.tasks.Task;
 import org.opensearch.transport.TransportService;
 
+import java.util.Objects;
+
+import static org.opensearch.common.breaker.ResponseLimitSettings.LimitEntity.SHARDS;
+
 /**
  * Perform cat shards action
  *
@@ -31,11 +37,18 @@
 public class TransportCatShardsAction extends HandledTransportAction<CatShardsRequest, CatShardsResponse> {
 
     private final NodeClient client;
+    private final ResponseLimitSettings responseLimitSettings;
 
     @Inject
-    public TransportCatShardsAction(NodeClient client, TransportService transportService, ActionFilters actionFilters) {
+    public TransportCatShardsAction(
+        NodeClient client,
+        TransportService transportService,
+        ActionFilters actionFilters,
+        ResponseLimitSettings responseLimitSettings
+    ) {
         super(CatShardsAction.NAME, transportService, actionFilters, CatShardsRequest::new);
         this.client = client;
+        this.responseLimitSettings = responseLimitSettings;
     }
 
     @Override
@@ -73,6 +86,7 @@ protected void innerOnFailure(Exception e) {
             client.admin().cluster().state(clusterStateRequest, new ActionListener<ClusterStateResponse>() {
                 @Override
                 public void onResponse(ClusterStateResponse clusterStateResponse) {
+                    validateRequestLimit(shardsRequest, clusterStateResponse, cancellableListener);
                     catShardsResponse.setClusterStateResponse(clusterStateResponse);
                     IndicesStatsRequest indicesStatsRequest = new IndicesStatsRequest();
                     indicesStatsRequest.setShouldCancelOnTimeout(true);
@@ -107,4 +121,19 @@ public void onFailure(Exception e) {
         }
 
     }
+
+    private void validateRequestLimit(
+        final CatShardsRequest shardsRequest,
+        final ClusterStateResponse clusterStateResponse,
+        final ActionListener<CatShardsResponse> listener
+    ) {
+        if (shardsRequest.isRequestLimitCheckSupported()
+            && Objects.nonNull(clusterStateResponse)
+            && Objects.nonNull(clusterStateResponse.getState())) {
+            int limit = responseLimitSettings.getCatShardsResponseLimit();
+            if (ResponseLimitSettings.isResponseLimitBreached(clusterStateResponse.getState().getRoutingTable(), SHARDS, limit)) {
+                listener.onFailure(new ResponseLimitBreachedException("Too many shards requested.", limit, SHARDS));
+            }
+        }
+    }
 }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/stats/TransportClusterStatsAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/stats/TransportClusterStatsAction.java
index a49ca2035783c..c4b3524cf6da5 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/stats/TransportClusterStatsAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/stats/TransportClusterStatsAction.java
@@ -174,6 +174,7 @@ protected ClusterStatsNodeResponse nodeOperation(ClusterStatsNodeRequest nodeReq
             false,
             false,
             false,
+            false,
             false
         );
         List<ShardStats> shardsStats = new ArrayList<>();
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/shards/TransportIndicesShardStoresAction.java b/server/src/main/java/org/opensearch/action/admin/indices/shards/TransportIndicesShardStoresAction.java
index a8b97d0f344ae..1a3c657f5b1b8 100644
--- a/server/src/main/java/org/opensearch/action/admin/indices/shards/TransportIndicesShardStoresAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/indices/shards/TransportIndicesShardStoresAction.java
@@ -37,6 +37,7 @@
 import org.opensearch.action.FailedNodeException;
 import org.opensearch.action.support.ActionFilters;
 import org.opensearch.action.support.clustermanager.TransportClusterManagerNodeReadAction;
+import org.opensearch.cluster.ClusterManagerMetrics;
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.block.ClusterBlockException;
 import org.opensearch.cluster.block.ClusterBlockLevel;
@@ -88,6 +89,7 @@ public class TransportIndicesShardStoresAction extends TransportClusterManagerNo
     private static final Logger logger = LogManager.getLogger(TransportIndicesShardStoresAction.class);
 
     private final TransportNodesListGatewayStartedShards listShardStoresInfo;
+    private final ClusterManagerMetrics clusterManagerMetrics;
 
     @Inject
     public TransportIndicesShardStoresAction(
@@ -96,7 +98,8 @@ public TransportIndicesShardStoresAction(
         ThreadPool threadPool,
         ActionFilters actionFilters,
         IndexNameExpressionResolver indexNameExpressionResolver,
-        TransportNodesListGatewayStartedShards listShardStoresInfo
+        TransportNodesListGatewayStartedShards listShardStoresInfo,
+        ClusterManagerMetrics clusterManagerMetrics
     ) {
         super(
             IndicesShardStoresAction.NAME,
@@ -109,6 +112,7 @@ public TransportIndicesShardStoresAction(
             true
         );
         this.listShardStoresInfo = listShardStoresInfo;
+        this.clusterManagerMetrics = clusterManagerMetrics;
     }
 
     @Override
@@ -154,7 +158,7 @@ protected void clusterManagerOperation(
         // we could fetch all shard store info from every node once (nNodes requests)
         // we have to implement a TransportNodesAction instead of using TransportNodesListGatewayStartedShards
         // for fetching shard stores info, that operates on a list of shards instead of a single shard
-        new AsyncShardStoresInfoFetches(state.nodes(), routingNodes, shardsToFetch, listener).start();
+        new AsyncShardStoresInfoFetches(state.nodes(), routingNodes, shardsToFetch, listener, clusterManagerMetrics).start();
     }
 
     @Override
@@ -175,12 +179,14 @@ private class AsyncShardStoresInfoFetches {
         private final ActionListener<IndicesShardStoresResponse> listener;
         private CountDown expectedOps;
         private final Queue<InternalAsyncFetch.Response> fetchResponses;
+        private final ClusterManagerMetrics clusterManagerMetrics;
 
         AsyncShardStoresInfoFetches(
             DiscoveryNodes nodes,
             RoutingNodes routingNodes,
             Set<Tuple<ShardId, String>> shards,
-            ActionListener<IndicesShardStoresResponse> listener
+            ActionListener<IndicesShardStoresResponse> listener,
+            ClusterManagerMetrics clusterManagerMetrics
         ) {
             this.nodes = nodes;
             this.routingNodes = routingNodes;
@@ -188,6 +194,7 @@ private class AsyncShardStoresInfoFetches {
             this.listener = listener;
             this.fetchResponses = new ConcurrentLinkedQueue<>();
             this.expectedOps = new CountDown(shards.size());
+            this.clusterManagerMetrics = clusterManagerMetrics;
         }
 
         void start() {
@@ -195,7 +202,14 @@ void start() {
                 listener.onResponse(new IndicesShardStoresResponse());
             } else {
                 for (Tuple<ShardId, String> shard : shards) {
-                    InternalAsyncFetch fetch = new InternalAsyncFetch(logger, "shard_stores", shard.v1(), shard.v2(), listShardStoresInfo);
+                    InternalAsyncFetch fetch = new InternalAsyncFetch(
+                        logger,
+                        "shard_stores",
+                        shard.v1(),
+                        shard.v2(),
+                        listShardStoresInfo,
+                        clusterManagerMetrics
+                    );
                     fetch.fetchData(nodes, Collections.emptyMap());
                 }
             }
@@ -213,9 +227,10 @@ private class InternalAsyncFetch extends AsyncShardFetch<NodeGatewayStartedShard
                 String type,
                 ShardId shardId,
                 String customDataPath,
-                TransportNodesListGatewayStartedShards action
+                TransportNodesListGatewayStartedShards action,
+                ClusterManagerMetrics clusterManagerMetrics
             ) {
-                super(logger, type, shardId, customDataPath, action);
+                super(logger, type, shardId, customDataPath, action, clusterManagerMetrics);
             }
 
             @Override
diff --git a/server/src/main/java/org/opensearch/cluster/ClusterManagerMetrics.java b/server/src/main/java/org/opensearch/cluster/ClusterManagerMetrics.java
index a98349a4af5cd..ba63b3fd2d6d0 100644
--- a/server/src/main/java/org/opensearch/cluster/ClusterManagerMetrics.java
+++ b/server/src/main/java/org/opensearch/cluster/ClusterManagerMetrics.java
@@ -34,6 +34,8 @@ public final class ClusterManagerMetrics {
 
     public final Counter leaderCheckFailureCounter;
     public final Counter followerChecksFailureCounter;
+    public final Counter asyncFetchFailureCounter;
+    public final Counter asyncFetchSuccessCounter;
 
     public ClusterManagerMetrics(MetricsRegistry metricsRegistry) {
         clusterStateAppliersHistogram = metricsRegistry.createHistogram(
@@ -71,6 +73,17 @@ public ClusterManagerMetrics(MetricsRegistry metricsRegistry) {
             "Counter for number of failed leader checks",
             COUNTER_METRICS_UNIT
         );
+        asyncFetchFailureCounter = metricsRegistry.createCounter(
+            "async.fetch.failure.count",
+            "Counter for number of failed async fetches",
+            COUNTER_METRICS_UNIT
+        );
+        asyncFetchSuccessCounter = metricsRegistry.createCounter(
+            "async.fetch.success.count",
+            "Counter for number of successful async fetches",
+            COUNTER_METRICS_UNIT
+        );
+
     }
 
     public void recordLatency(Histogram histogram, Double value) {
diff --git a/server/src/main/java/org/opensearch/cluster/ClusterModule.java b/server/src/main/java/org/opensearch/cluster/ClusterModule.java
index 3924e8e0589a7..66b1740c8fa96 100644
--- a/server/src/main/java/org/opensearch/cluster/ClusterModule.java
+++ b/server/src/main/java/org/opensearch/cluster/ClusterModule.java
@@ -142,6 +142,7 @@ public class ClusterModule extends AbstractModule {
     // pkg private for tests
     final Collection<AllocationDecider> deciderList;
     final ShardsAllocator shardsAllocator;
+    private final ClusterManagerMetrics clusterManagerMetrics;
 
     public ClusterModule(
         Settings settings,
@@ -166,6 +167,7 @@ public ClusterModule(
             settings,
             clusterManagerMetrics
         );
+        this.clusterManagerMetrics = clusterManagerMetrics;
     }
 
     public static List<Entry> getNamedWriteables() {
@@ -456,6 +458,7 @@ protected void configure() {
         bind(TaskResultsService.class).asEagerSingleton();
         bind(AllocationDeciders.class).toInstance(allocationDeciders);
         bind(ShardsAllocator.class).toInstance(shardsAllocator);
+        bind(ClusterManagerMetrics.class).toInstance(clusterManagerMetrics);
     }
 
     public void setExistingShardsAllocators(GatewayAllocator gatewayAllocator, ShardsBatchGatewayAllocator shardsBatchGatewayAllocator) {
diff --git a/server/src/main/java/org/opensearch/cluster/SnapshotsInProgress.java b/server/src/main/java/org/opensearch/cluster/SnapshotsInProgress.java
index 595f6d54fd9be..e3f98a3f61534 100644
--- a/server/src/main/java/org/opensearch/cluster/SnapshotsInProgress.java
+++ b/server/src/main/java/org/opensearch/cluster/SnapshotsInProgress.java
@@ -412,7 +412,7 @@ private Entry(StreamInput in) throws IOException {
             } else {
                 remoteStoreIndexShallowCopy = false;
             }
-            if (in.getVersion().onOrAfter(Version.CURRENT)) {
+            if (in.getVersion().onOrAfter(Version.V_2_18_0)) {
                 remoteStoreIndexShallowCopyV2 = in.readBoolean();
             } else {
                 remoteStoreIndexShallowCopyV2 = false;
@@ -886,7 +886,7 @@ public void writeTo(StreamOutput out) throws IOException {
             if (out.getVersion().onOrAfter(Version.V_2_9_0)) {
                 out.writeBoolean(remoteStoreIndexShallowCopy);
             }
-            if (out.getVersion().onOrAfter(Version.CURRENT)) {
+            if (out.getVersion().onOrAfter(Version.V_2_18_0)) {
                 out.writeBoolean(remoteStoreIndexShallowCopyV2);
             }
         }
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/CoordinationState.java b/server/src/main/java/org/opensearch/cluster/coordination/CoordinationState.java
index 9cffc7051d756..e5b07f867d609 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/CoordinationState.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/CoordinationState.java
@@ -108,7 +108,7 @@ public CoordinationState(
         // ToDo: revisit this check while making the setting dynamic
         this.isRemotePublicationEnabled = isRemoteStateEnabled
             && REMOTE_PUBLICATION_SETTING.get(settings)
-            && localNode.isRemoteStatePublicationEnabled();
+            && localNode.isRemoteStatePublicationConfigured();
     }
 
     public boolean isRemotePublicationEnabled() {
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/Coordinator.java b/server/src/main/java/org/opensearch/cluster/coordination/Coordinator.java
index 9859abe503eaa..1b3ae89251ac0 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/Coordinator.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/Coordinator.java
@@ -189,6 +189,7 @@ public class Coordinator extends AbstractLifecycleComponent implements Discovery
     private final PersistedStateRegistry persistedStateRegistry;
     private final RemoteStoreNodeService remoteStoreNodeService;
     private NodeConnectionsService nodeConnectionsService;
+    private final RemoteClusterStateService remoteClusterStateService;
 
     /**
      * @param nodeName The name of the node, used to name the {@link java.util.concurrent.ExecutorService} of the {@link SeedHostsResolver}.
@@ -312,6 +313,7 @@ public Coordinator(
         this.persistedStateRegistry = persistedStateRegistry;
         this.localNodeCommissioned = true;
         this.remoteStoreNodeService = remoteStoreNodeService;
+        this.remoteClusterStateService = remoteClusterStateService;
     }
 
     private ClusterFormationState getClusterFormationState() {
@@ -912,9 +914,9 @@ public DiscoveryStats stats() {
                 stats.add(persistedStateRegistry.getPersistedState(stateType).getStats());
             }
         });
-        if (coordinationState.get().isRemotePublicationEnabled()) {
-            stats.add(publicationHandler.getFullDownloadStats());
-            stats.add(publicationHandler.getDiffDownloadStats());
+        if (remoteClusterStateService != null) {
+            stats.add(remoteClusterStateService.getFullDownloadStats());
+            stats.add(remoteClusterStateService.getDiffDownloadStats());
         }
         clusterStateStats.setPersistenceStats(stats);
         return new DiscoveryStats(new PendingClusterStateStats(0, 0, 0), publicationHandler.stats(), clusterStateStats);
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/JoinTaskExecutor.java b/server/src/main/java/org/opensearch/cluster/coordination/JoinTaskExecutor.java
index 13033b670d44b..aca8653be4dd8 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/JoinTaskExecutor.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/JoinTaskExecutor.java
@@ -513,10 +513,10 @@ private static void ensureRemoteClusterStateNodesCompatibility(DiscoveryNode joi
 
         assert existingNodes.isEmpty() == false;
         Optional<DiscoveryNode> remotePublicationNode = existingNodes.stream()
-            .filter(DiscoveryNode::isRemoteStatePublicationEnabled)
+            .filter(DiscoveryNode::isRemoteStatePublicationConfigured)
             .findFirst();
 
-        if (remotePublicationNode.isPresent() && joiningNode.isRemoteStatePublicationEnabled()) {
+        if (remotePublicationNode.isPresent() && joiningNode.isRemoteStatePublicationConfigured()) {
             ensureRepositoryCompatibility(joiningNode, remotePublicationNode.get(), REMOTE_CLUSTER_PUBLICATION_REPO_NAME_ATTRIBUTES);
         }
     }
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/PublicationTransportHandler.java b/server/src/main/java/org/opensearch/cluster/coordination/PublicationTransportHandler.java
index caed2b6eceb49..6277b70f9a7c8 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/PublicationTransportHandler.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/PublicationTransportHandler.java
@@ -178,14 +178,6 @@ public PublishClusterStateStats stats() {
         );
     }
 
-    public PersistedStateStats getFullDownloadStats() {
-        return remoteClusterStateService.getFullDownloadStats();
-    }
-
-    public PersistedStateStats getDiffDownloadStats() {
-        return remoteClusterStateService.getDiffDownloadStats();
-    }
-
     private PublishWithJoinResponse handleIncomingPublishRequest(BytesTransportRequest request) throws IOException {
         try (StreamInput in = CompressedStreamUtils.decompressBytes(request, namedWriteableRegistry)) {
             ClusterState incomingState;
@@ -356,7 +348,7 @@ public PublicationContext newPublicationContext(
     ) {
         if (isRemotePublicationEnabled == true) {
             if (allNodesRemotePublicationEnabled.get() == false) {
-                if (validateRemotePublicationOnAllNodes(clusterChangedEvent.state().nodes()) == true) {
+                if (validateRemotePublicationConfiguredOnAllNodes(clusterChangedEvent.state().nodes()) == true) {
                     allNodesRemotePublicationEnabled.set(true);
                 }
             }
@@ -374,11 +366,11 @@ public PublicationContext newPublicationContext(
         return publicationContext;
     }
 
-    private boolean validateRemotePublicationOnAllNodes(DiscoveryNodes discoveryNodes) {
+    private boolean validateRemotePublicationConfiguredOnAllNodes(DiscoveryNodes discoveryNodes) {
         assert ClusterMetadataManifest.getCodecForVersion(discoveryNodes.getMinNodeVersion()) >= ClusterMetadataManifest.CODEC_V0;
         for (DiscoveryNode node : discoveryNodes.getNodes().values()) {
             // if a node is non-remote then created local publication context
-            if (node.isRemoteStatePublicationEnabled() == false) {
+            if (node.isRemoteStatePublicationConfigured() == false) {
                 return false;
             }
         }
diff --git a/server/src/main/java/org/opensearch/cluster/node/DiscoveryNode.java b/server/src/main/java/org/opensearch/cluster/node/DiscoveryNode.java
index a6f0a457f7f9b..b06c2ef0bdbe4 100644
--- a/server/src/main/java/org/opensearch/cluster/node/DiscoveryNode.java
+++ b/server/src/main/java/org/opensearch/cluster/node/DiscoveryNode.java
@@ -515,10 +515,10 @@ public boolean isRemoteStoreNode() {
     }
 
     /**
-     * Returns whether remote cluster state publication is enabled on this node
+     * Returns whether settings required for remote cluster state publication is configured
      * @return true if the node contains remote cluster state node attribute and remote routing table node attribute
      */
-    public boolean isRemoteStatePublicationEnabled() {
+    public boolean isRemoteStatePublicationConfigured() {
         return this.getAttributes()
             .keySet()
             .stream()
diff --git a/server/src/main/java/org/opensearch/common/Table.java b/server/src/main/java/org/opensearch/common/Table.java
index da14f628efa0f..133ec3052e6c9 100644
--- a/server/src/main/java/org/opensearch/common/Table.java
+++ b/server/src/main/java/org/opensearch/common/Table.java
@@ -34,6 +34,7 @@
 
 import org.opensearch.common.time.DateFormatter;
 import org.opensearch.core.common.Strings;
+import org.opensearch.rest.pagination.PageToken;
 
 import java.time.Instant;
 import java.time.ZoneOffset;
@@ -59,9 +60,19 @@ public class Table {
     private List<Cell> currentCells;
     private boolean inHeaders = false;
     private boolean withTime = false;
+    /**
+     * paginatedQueryResponse if null will imply the Table response is not paginated.
+     */
+    private PageToken pageToken;
     public static final String EPOCH = "epoch";
     public static final String TIMESTAMP = "timestamp";
 
+    public Table() {}
+
+    public Table(@Nullable PageToken pageToken) {
+        this.pageToken = pageToken;
+    }
+
     public Table startHeaders() {
         inHeaders = true;
         currentCells = new ArrayList<>();
@@ -230,6 +241,10 @@ public Map<String, String> getAliasMap() {
         return headerAliasMap;
     }
 
+    public PageToken getPageToken() {
+        return pageToken;
+    }
+
     /**
      * Cell in a table
      *
diff --git a/server/src/main/java/org/opensearch/common/breaker/ResponseLimitBreachedException.java b/server/src/main/java/org/opensearch/common/breaker/ResponseLimitBreachedException.java
new file mode 100644
index 0000000000000..db6785067edf6
--- /dev/null
+++ b/server/src/main/java/org/opensearch/common/breaker/ResponseLimitBreachedException.java
@@ -0,0 +1,66 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.common.breaker;
+
+import org.opensearch.OpenSearchException;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.common.io.stream.StreamOutput;
+import org.opensearch.core.rest.RestStatus;
+import org.opensearch.core.xcontent.XContentBuilder;
+
+import java.io.IOException;
+
+/**
+ * Thrown when api response breaches threshold limit.
+ *
+ * @opensearch.internal
+ */
+public class ResponseLimitBreachedException extends OpenSearchException {
+
+    private final int responseLimit;
+    private final ResponseLimitSettings.LimitEntity limitEntity;
+
+    public ResponseLimitBreachedException(StreamInput in) throws IOException {
+        super(in);
+        responseLimit = in.readVInt();
+        limitEntity = in.readEnum(ResponseLimitSettings.LimitEntity.class);
+    }
+
+    public ResponseLimitBreachedException(String msg, int responseLimit, ResponseLimitSettings.LimitEntity limitEntity) {
+        super(msg);
+        this.responseLimit = responseLimit;
+        this.limitEntity = limitEntity;
+    }
+
+    @Override
+    public void writeTo(StreamOutput out) throws IOException {
+        super.writeTo(out);
+        out.writeVInt(responseLimit);
+        out.writeEnum(limitEntity);
+    }
+
+    public int getResponseLimit() {
+        return responseLimit;
+    }
+
+    public ResponseLimitSettings.LimitEntity getLimitEntity() {
+        return limitEntity;
+    }
+
+    @Override
+    public RestStatus status() {
+        return RestStatus.TOO_MANY_REQUESTS;
+    }
+
+    @Override
+    protected void metadataToXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.field("response_limit", responseLimit);
+        builder.field("limit_entity", limitEntity);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/common/breaker/ResponseLimitSettings.java b/server/src/main/java/org/opensearch/common/breaker/ResponseLimitSettings.java
new file mode 100644
index 0000000000000..8eb47c9aaf147
--- /dev/null
+++ b/server/src/main/java/org/opensearch/common/breaker/ResponseLimitSettings.java
@@ -0,0 +1,180 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.common.breaker;
+
+import org.opensearch.cluster.metadata.Metadata;
+import org.opensearch.cluster.routing.IndexRoutingTable;
+import org.opensearch.cluster.routing.IndexShardRoutingTable;
+import org.opensearch.cluster.routing.RoutingTable;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Setting;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.rest.action.cat.RestIndicesAction;
+import org.opensearch.rest.action.cat.RestSegmentsAction;
+import org.opensearch.rest.action.cat.RestShardsAction;
+
+import java.util.Map;
+import java.util.Objects;
+import java.util.function.Function;
+
+/**
+ * Class to define dynamic settings for putting response limits on the actions and methods to evaluate if block is required.
+ */
+public class ResponseLimitSettings {
+
+    /**
+     * Enum to represent entity against which we need to perform limit checks.
+     */
+    public enum LimitEntity {
+        INDICES,
+        SHARDS
+    }
+
+    private volatile int catIndicesResponseLimit;
+    private volatile int catShardsResponseLimit;
+    private volatile int catSegmentsResponseLimit;
+
+    /**
+     * Setting to enable response limit on {@link RestIndicesAction}. The limit will be applied on number of indices.
+     */
+    public static final Setting<Integer> CAT_INDICES_RESPONSE_LIMIT_SETTING = Setting.intSetting(
+        "cat.indices.response.limit.number_of_indices",
+        -1,
+        Setting.Property.NodeScope,
+        Setting.Property.Dynamic
+    );
+
+    /**
+     * Setting to enable response limit on {@link RestShardsAction}. The limit will be applied on number of shards.
+     */
+    public static final Setting<Integer> CAT_SHARDS_RESPONSE_LIMIT_SETTING = Setting.intSetting(
+        "cat.shards.response.limit.number_of_shards",
+        -1,
+        Setting.Property.NodeScope,
+        Setting.Property.Dynamic
+    );
+
+    /**
+     * Setting to enable response limit on {@link RestSegmentsAction}. The limit will be applied on number of indices.
+     */
+    public static final Setting<Integer> CAT_SEGMENTS_RESPONSE_LIMIT_SETTING = Setting.intSetting(
+        "cat.segments.response.limit.number_of_indices",
+        -1,
+        Setting.Property.NodeScope,
+        Setting.Property.Dynamic
+    );
+
+    public ResponseLimitSettings(ClusterSettings clusterSettings, Settings settings) {
+        setCatShardsResponseLimit(CAT_SHARDS_RESPONSE_LIMIT_SETTING.get(settings));
+        setCatIndicesResponseLimit(CAT_INDICES_RESPONSE_LIMIT_SETTING.get(settings));
+        setCatSegmentsResponseLimit(CAT_SEGMENTS_RESPONSE_LIMIT_SETTING.get(settings));
+
+        clusterSettings.addSettingsUpdateConsumer(CAT_SHARDS_RESPONSE_LIMIT_SETTING, this::setCatShardsResponseLimit);
+        clusterSettings.addSettingsUpdateConsumer(CAT_INDICES_RESPONSE_LIMIT_SETTING, this::setCatIndicesResponseLimit);
+        clusterSettings.addSettingsUpdateConsumer(CAT_SEGMENTS_RESPONSE_LIMIT_SETTING, this::setCatSegmentsResponseLimit);
+    }
+
+    /**
+     * Method to check if the response limit has reached for an action.
+     * The limits are controlled via dynamic settings.
+     *
+     * @param metadata     {@link Metadata}
+     * @param limitEntity  {@link LimitEntity}
+     * @param limit        Integer limit on block entity
+     * @return True/False
+     */
+    public static boolean isResponseLimitBreached(final Metadata metadata, final LimitEntity limitEntity, final int limit) {
+        if (Objects.isNull(metadata) || limit <= 0) return false;
+        if (limitEntity == LimitEntity.INDICES) {
+            int indicesCount = getTotalIndicesFromMetadata.apply(metadata);
+            return indicesCount > limit;
+        } else {
+            throw new IllegalArgumentException("Unsupported limit entity [" + limitEntity + "]");
+        }
+    }
+
+    /**
+     * Method to check if the response limit has reached for an action.
+     * The limits are controlled via dynamic settings.
+     *
+     * @param routingTable {@link RoutingTable}
+     * @param limitEntity  {@link LimitEntity}
+     * @param limit        Integer limit on block entity
+     * @return True/False
+     */
+    public static boolean isResponseLimitBreached(final RoutingTable routingTable, final LimitEntity limitEntity, final int limit) {
+        if (Objects.isNull(routingTable) || limit <= 0) return false;
+        if (Objects.isNull(limitEntity)) {
+            throw new IllegalArgumentException("Limit entity cannot be null");
+        }
+        switch (limitEntity) {
+            case INDICES:
+                int indicesCount = getTotalIndicesFromRoutingTable.apply(routingTable);
+                if (indicesCount > limit) return true;
+                break;
+            case SHARDS:
+                if (isShardsLimitBreached(routingTable, limit)) return true;
+                break;
+            default:
+                throw new IllegalArgumentException("Unsupported limit entity [" + limitEntity + "]");
+        }
+        return false;
+    }
+
+    private static boolean isShardsLimitBreached(final RoutingTable routingTable, final int limit) {
+        final Map<String, IndexRoutingTable> indexRoutingTableMap = routingTable.getIndicesRouting();
+        int totalShards = 0;
+        for (final Map.Entry<String, IndexRoutingTable> entry : indexRoutingTableMap.entrySet()) {
+            for (final Map.Entry<Integer, IndexShardRoutingTable> indexShardRoutingTableEntry : entry.getValue().getShards().entrySet()) {
+                totalShards += indexShardRoutingTableEntry.getValue().getShards().size();
+                // Fail fast if limit value is breached and avoid unnecessary computation.
+                if (totalShards > limit) return true;
+            }
+        }
+        return false;
+    }
+
+    private void setCatShardsResponseLimit(final int catShardsResponseLimit) {
+        this.catShardsResponseLimit = catShardsResponseLimit;
+    }
+
+    private void setCatIndicesResponseLimit(final int catIndicesResponseLimit) {
+        this.catIndicesResponseLimit = catIndicesResponseLimit;
+    }
+
+    private void setCatSegmentsResponseLimit(final int catSegmentsResponseLimit) {
+        this.catSegmentsResponseLimit = catSegmentsResponseLimit;
+    }
+
+    public int getCatShardsResponseLimit() {
+        return this.catShardsResponseLimit;
+    }
+
+    public int getCatIndicesResponseLimit() {
+        return this.catIndicesResponseLimit;
+    }
+
+    public int getCatSegmentsResponseLimit() {
+        return this.catSegmentsResponseLimit;
+    }
+
+    static Function<Metadata, Integer> getTotalIndicesFromMetadata = (metadata) -> {
+        if (Objects.nonNull(metadata) && Objects.nonNull(metadata.getIndices())) {
+            return metadata.getIndices().size();
+        }
+        return 0;
+    };
+
+    static Function<RoutingTable, Integer> getTotalIndicesFromRoutingTable = (routingTable) -> {
+        if (Objects.nonNull(routingTable) && Objects.nonNull(routingTable.getIndicesRouting())) {
+            return routingTable.getIndicesRouting().size();
+        }
+        return 0;
+    };
+}
diff --git a/server/src/main/java/org/opensearch/common/settings/ClusterSettings.java b/server/src/main/java/org/opensearch/common/settings/ClusterSettings.java
index ecdd23530c648..e18c4dabb29eb 100644
--- a/server/src/main/java/org/opensearch/common/settings/ClusterSettings.java
+++ b/server/src/main/java/org/opensearch/common/settings/ClusterSettings.java
@@ -84,6 +84,7 @@
 import org.opensearch.cluster.service.ClusterManagerTaskThrottler;
 import org.opensearch.cluster.service.ClusterService;
 import org.opensearch.common.annotation.PublicApi;
+import org.opensearch.common.breaker.ResponseLimitSettings;
 import org.opensearch.common.cache.CacheType;
 import org.opensearch.common.cache.settings.CacheSettings;
 import org.opensearch.common.cache.store.settings.OpenSearchOnHeapCacheSettings;
@@ -796,7 +797,12 @@ public void apply(Settings value, Settings current, Settings previous) {
                 WorkloadManagementSettings.NODE_LEVEL_CPU_REJECTION_THRESHOLD,
                 WorkloadManagementSettings.NODE_LEVEL_CPU_CANCELLATION_THRESHOLD,
                 WorkloadManagementSettings.NODE_LEVEL_MEMORY_REJECTION_THRESHOLD,
-                WorkloadManagementSettings.NODE_LEVEL_MEMORY_CANCELLATION_THRESHOLD
+                WorkloadManagementSettings.NODE_LEVEL_MEMORY_CANCELLATION_THRESHOLD,
+
+                // Settings to be used for limiting rest requests
+                ResponseLimitSettings.CAT_INDICES_RESPONSE_LIMIT_SETTING,
+                ResponseLimitSettings.CAT_SHARDS_RESPONSE_LIMIT_SETTING,
+                ResponseLimitSettings.CAT_SEGMENTS_RESPONSE_LIMIT_SETTING
             )
         )
     );
diff --git a/server/src/main/java/org/opensearch/common/settings/FeatureFlagSettings.java b/server/src/main/java/org/opensearch/common/settings/FeatureFlagSettings.java
index 73375f9eaa413..59d999798868e 100644
--- a/server/src/main/java/org/opensearch/common/settings/FeatureFlagSettings.java
+++ b/server/src/main/java/org/opensearch/common/settings/FeatureFlagSettings.java
@@ -31,7 +31,6 @@ protected FeatureFlagSettings(
 
     public static final Set<Setting<?>> BUILT_IN_FEATURE_FLAGS = Set.of(
         FeatureFlags.EXTENSIONS_SETTING,
-        FeatureFlags.IDENTITY_SETTING,
         FeatureFlags.TELEMETRY_SETTING,
         FeatureFlags.DATETIME_FORMATTER_CACHING_SETTING,
         FeatureFlags.TIERED_REMOTE_INDEX_SETTING,
diff --git a/server/src/main/java/org/opensearch/common/util/FeatureFlags.java b/server/src/main/java/org/opensearch/common/util/FeatureFlags.java
index a5acea004c3b2..6df68013a8119 100644
--- a/server/src/main/java/org/opensearch/common/util/FeatureFlags.java
+++ b/server/src/main/java/org/opensearch/common/util/FeatureFlags.java
@@ -40,11 +40,6 @@ public class FeatureFlags {
      */
     public static final String EXTENSIONS = "opensearch.experimental.feature.extensions.enabled";
 
-    /**
-     * Gates the functionality of identity.
-     */
-    public static final String IDENTITY = "opensearch.experimental.feature.identity.enabled";
-
     /**
      * Gates the functionality of telemetry framework.
      */
@@ -82,8 +77,6 @@ public class FeatureFlags {
 
     public static final Setting<Boolean> EXTENSIONS_SETTING = Setting.boolSetting(EXTENSIONS, false, Property.NodeScope);
 
-    public static final Setting<Boolean> IDENTITY_SETTING = Setting.boolSetting(IDENTITY, false, Property.NodeScope);
-
     public static final Setting<Boolean> TELEMETRY_SETTING = Setting.boolSetting(TELEMETRY, false, Property.NodeScope);
 
     public static final Setting<Boolean> DATETIME_FORMATTER_CACHING_SETTING = Setting.boolSetting(
@@ -138,7 +131,6 @@ public class FeatureFlags {
     private static final List<Setting<Boolean>> ALL_FEATURE_FLAG_SETTINGS = List.of(
         REMOTE_STORE_MIGRATION_EXPERIMENTAL_SETTING,
         EXTENSIONS_SETTING,
-        IDENTITY_SETTING,
         TELEMETRY_SETTING,
         DATETIME_FORMATTER_CACHING_SETTING,
         TIERED_REMOTE_INDEX_SETTING,
diff --git a/server/src/main/java/org/opensearch/gateway/AsyncShardBatchFetch.java b/server/src/main/java/org/opensearch/gateway/AsyncShardBatchFetch.java
index df642a9f5a743..d86d41bb1a359 100644
--- a/server/src/main/java/org/opensearch/gateway/AsyncShardBatchFetch.java
+++ b/server/src/main/java/org/opensearch/gateway/AsyncShardBatchFetch.java
@@ -11,6 +11,7 @@
 import org.apache.logging.log4j.Logger;
 import org.opensearch.action.support.nodes.BaseNodeResponse;
 import org.opensearch.action.support.nodes.BaseNodesResponse;
+import org.opensearch.cluster.ClusterManagerMetrics;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.common.logging.Loggers;
 import org.opensearch.core.index.shard.ShardId;
@@ -48,7 +49,8 @@ public abstract class AsyncShardBatchFetch<T extends BaseNodeResponse, V> extend
         Class<V> clazz,
         V emptyShardResponse,
         Predicate<V> emptyShardResponsePredicate,
-        ShardBatchResponseFactory<T, V> responseFactory
+        ShardBatchResponseFactory<T, V> responseFactory,
+        ClusterManagerMetrics clusterManagerMetrics
     ) {
         super(
             logger,
@@ -64,7 +66,8 @@ public abstract class AsyncShardBatchFetch<T extends BaseNodeResponse, V> extend
                 clazz,
                 emptyShardResponse,
                 emptyShardResponsePredicate,
-                responseFactory
+                responseFactory,
+                clusterManagerMetrics
             )
         );
     }
@@ -116,9 +119,10 @@ public ShardBatchCache(
             Class<V> clazz,
             V emptyResponse,
             Predicate<V> emptyShardResponsePredicate,
-            ShardBatchResponseFactory<T, V> responseFactory
+            ShardBatchResponseFactory<T, V> responseFactory,
+            ClusterManagerMetrics clusterManagerMetrics
         ) {
-            super(Loggers.getLogger(logger, "_" + logKey), type);
+            super(Loggers.getLogger(logger, "_" + logKey), type, clusterManagerMetrics);
             this.batchSize = shardAttributesMap.size();
             this.emptyShardResponsePredicate = emptyShardResponsePredicate;
             cache = new HashMap<>();
diff --git a/server/src/main/java/org/opensearch/gateway/AsyncShardFetch.java b/server/src/main/java/org/opensearch/gateway/AsyncShardFetch.java
index b664dd573ce67..6017743ef2bd0 100644
--- a/server/src/main/java/org/opensearch/gateway/AsyncShardFetch.java
+++ b/server/src/main/java/org/opensearch/gateway/AsyncShardFetch.java
@@ -35,6 +35,7 @@
 import org.opensearch.action.FailedNodeException;
 import org.opensearch.action.support.nodes.BaseNodeResponse;
 import org.opensearch.action.support.nodes.BaseNodesResponse;
+import org.opensearch.cluster.ClusterManagerMetrics;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNodes;
 import org.opensearch.cluster.routing.allocation.RoutingAllocation;
@@ -94,7 +95,8 @@ protected AsyncShardFetch(
         String type,
         ShardId shardId,
         String customDataPath,
-        Lister<? extends BaseNodesResponse<T>, T> action
+        Lister<? extends BaseNodesResponse<T>, T> action,
+        ClusterManagerMetrics clusterManagerMetrics
     ) {
         this.logger = logger;
         this.type = type;
@@ -102,7 +104,7 @@ protected AsyncShardFetch(
         shardAttributesMap.put(shardId, new ShardAttributes(customDataPath));
         this.action = (Lister<BaseNodesResponse<T>, T>) action;
         this.reroutingKey = "ShardId=[" + shardId.toString() + "]";
-        cache = new ShardCache<>(logger, reroutingKey, type);
+        cache = new ShardCache<>(logger, reroutingKey, type, clusterManagerMetrics);
     }
 
     /**
@@ -284,8 +286,8 @@ static class ShardCache<K extends BaseNodeResponse> extends AsyncShardFetchCache
 
         private final Map<String, NodeEntry<K>> cache;
 
-        public ShardCache(Logger logger, String logKey, String type) {
-            super(Loggers.getLogger(logger, "_" + logKey), type);
+        public ShardCache(Logger logger, String logKey, String type, ClusterManagerMetrics clusterManagerMetrics) {
+            super(Loggers.getLogger(logger, "_" + logKey), type, clusterManagerMetrics);
             cache = new HashMap<>();
         }
 
diff --git a/server/src/main/java/org/opensearch/gateway/AsyncShardFetchCache.java b/server/src/main/java/org/opensearch/gateway/AsyncShardFetchCache.java
index 2a4e6181467b0..9b0a95f611e0e 100644
--- a/server/src/main/java/org/opensearch/gateway/AsyncShardFetchCache.java
+++ b/server/src/main/java/org/opensearch/gateway/AsyncShardFetchCache.java
@@ -14,6 +14,7 @@
 import org.opensearch.OpenSearchTimeoutException;
 import org.opensearch.action.FailedNodeException;
 import org.opensearch.action.support.nodes.BaseNodeResponse;
+import org.opensearch.cluster.ClusterManagerMetrics;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNodes;
 import org.opensearch.core.concurrency.OpenSearchRejectedExecutionException;
@@ -51,10 +52,12 @@ public abstract class AsyncShardFetchCache<K extends BaseNodeResponse> {
 
     private final Logger logger;
     private final String type;
+    private final ClusterManagerMetrics clusterManagerMetrics;
 
-    protected AsyncShardFetchCache(Logger logger, String type) {
+    protected AsyncShardFetchCache(Logger logger, String type, ClusterManagerMetrics clusterManagerMetrics) {
         this.logger = logger;
         this.type = type;
+        this.clusterManagerMetrics = clusterManagerMetrics;
     }
 
     abstract void initData(DiscoveryNode node);
@@ -162,6 +165,7 @@ Map<DiscoveryNode, K> getCacheData(DiscoveryNodes nodes, Set<String> failedNodes
     }
 
     void processResponses(List<K> responses, long fetchingRound) {
+        clusterManagerMetrics.incrementCounter(clusterManagerMetrics.asyncFetchSuccessCounter, Double.valueOf(responses.size()));
         for (K response : responses) {
             BaseNodeEntry nodeEntry = getCache().get(response.getNode().getId());
             if (nodeEntry != null) {
@@ -222,6 +226,7 @@ boolean retryableException(Throwable unwrappedCause) {
     }
 
     void processFailures(List<FailedNodeException> failures, long fetchingRound) {
+        clusterManagerMetrics.incrementCounter(clusterManagerMetrics.asyncFetchFailureCounter, Double.valueOf(failures.size()));
         for (FailedNodeException failure : failures) {
             logger.trace("processing failure {} for [{}]", failure, type);
             BaseNodeEntry nodeEntry = getCache().get(failure.nodeId());
diff --git a/server/src/main/java/org/opensearch/gateway/GatewayAllocator.java b/server/src/main/java/org/opensearch/gateway/GatewayAllocator.java
index c8ef9364ebba9..eaacb5dbfbd17 100644
--- a/server/src/main/java/org/opensearch/gateway/GatewayAllocator.java
+++ b/server/src/main/java/org/opensearch/gateway/GatewayAllocator.java
@@ -37,6 +37,7 @@
 import org.apache.logging.log4j.message.ParameterizedMessage;
 import org.opensearch.action.support.nodes.BaseNodeResponse;
 import org.opensearch.action.support.nodes.BaseNodesResponse;
+import org.opensearch.cluster.ClusterManagerMetrics;
 import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNodes;
@@ -92,11 +93,12 @@ public class GatewayAllocator implements ExistingShardsAllocator {
     public GatewayAllocator(
         RerouteService rerouteService,
         TransportNodesListGatewayStartedShards startedAction,
-        TransportNodesListShardStoreMetadata storeAction
+        TransportNodesListShardStoreMetadata storeAction,
+        ClusterManagerMetrics clusterManagerMetrics
     ) {
         this.rerouteService = rerouteService;
-        this.primaryShardAllocator = new InternalPrimaryShardAllocator(startedAction);
-        this.replicaShardAllocator = new InternalReplicaShardAllocator(storeAction);
+        this.primaryShardAllocator = new InternalPrimaryShardAllocator(startedAction, clusterManagerMetrics);
+        this.replicaShardAllocator = new InternalReplicaShardAllocator(storeAction, clusterManagerMetrics);
     }
 
     @Override
@@ -251,9 +253,10 @@ class InternalAsyncFetch<T extends BaseNodeResponse> extends AsyncShardFetch<T>
             String type,
             ShardId shardId,
             String customDataPath,
-            Lister<? extends BaseNodesResponse<T>, T> action
+            Lister<? extends BaseNodesResponse<T>, T> action,
+            ClusterManagerMetrics clusterManagerMetrics
         ) {
-            super(logger, type, shardId, customDataPath, action);
+            super(logger, type, shardId, customDataPath, action, clusterManagerMetrics);
         }
 
         @Override
@@ -274,9 +277,11 @@ protected void reroute(String reroutingKey, String reason) {
     class InternalPrimaryShardAllocator extends PrimaryShardAllocator {
 
         private final TransportNodesListGatewayStartedShards startedAction;
+        private final ClusterManagerMetrics clusterManagerMetrics;
 
-        InternalPrimaryShardAllocator(TransportNodesListGatewayStartedShards startedAction) {
+        InternalPrimaryShardAllocator(TransportNodesListGatewayStartedShards startedAction, ClusterManagerMetrics clusterManagerMetrics) {
             this.startedAction = startedAction;
+            this.clusterManagerMetrics = clusterManagerMetrics;
         }
 
         @Override
@@ -291,7 +296,8 @@ protected AsyncShardFetch.FetchResult<TransportNodesListGatewayStartedShards.Nod
                     "shard_started",
                     shardId,
                     IndexMetadata.INDEX_DATA_PATH_SETTING.get(allocation.metadata().index(shard.index()).getSettings()),
-                    startedAction
+                    startedAction,
+                    clusterManagerMetrics
                 )
             );
             AsyncShardFetch.FetchResult<TransportNodesListGatewayStartedShards.NodeGatewayStartedShards> shardState = fetch.fetchData(
@@ -313,9 +319,11 @@ protected AsyncShardFetch.FetchResult<TransportNodesListGatewayStartedShards.Nod
     class InternalReplicaShardAllocator extends ReplicaShardAllocator {
 
         private final TransportNodesListShardStoreMetadata storeAction;
+        private final ClusterManagerMetrics clusterManagerMetrics;
 
-        InternalReplicaShardAllocator(TransportNodesListShardStoreMetadata storeAction) {
+        InternalReplicaShardAllocator(TransportNodesListShardStoreMetadata storeAction, ClusterManagerMetrics clusterManagerMetrics) {
             this.storeAction = storeAction;
+            this.clusterManagerMetrics = clusterManagerMetrics;
         }
 
         @Override
@@ -330,7 +338,8 @@ protected AsyncShardFetch.FetchResult<TransportNodesListShardStoreMetadata.NodeS
                     "shard_store",
                     shard.shardId(),
                     IndexMetadata.INDEX_DATA_PATH_SETTING.get(allocation.metadata().index(shard.index()).getSettings()),
-                    storeAction
+                    storeAction,
+                    clusterManagerMetrics
                 )
             );
             AsyncShardFetch.FetchResult<TransportNodesListShardStoreMetadata.NodeStoreFilesMetadata> shardStores = fetch.fetchData(
diff --git a/server/src/main/java/org/opensearch/gateway/ShardsBatchGatewayAllocator.java b/server/src/main/java/org/opensearch/gateway/ShardsBatchGatewayAllocator.java
index 5e2dcbcd70b40..d7c0a66ba3424 100644
--- a/server/src/main/java/org/opensearch/gateway/ShardsBatchGatewayAllocator.java
+++ b/server/src/main/java/org/opensearch/gateway/ShardsBatchGatewayAllocator.java
@@ -13,6 +13,7 @@
 import org.apache.logging.log4j.message.ParameterizedMessage;
 import org.opensearch.action.support.nodes.BaseNodeResponse;
 import org.opensearch.action.support.nodes.BaseNodesResponse;
+import org.opensearch.cluster.ClusterManagerMetrics;
 import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNodes;
@@ -44,6 +45,7 @@
 import org.opensearch.indices.store.TransportNodesListShardStoreMetadataBatch.NodeStoreFilesMetadata;
 import org.opensearch.indices.store.TransportNodesListShardStoreMetadataHelper;
 import org.opensearch.indices.store.TransportNodesListShardStoreMetadataHelper.StoreFilesMetadata;
+import org.opensearch.telemetry.metrics.noop.NoopMetricsRegistry;
 
 import java.util.ArrayList;
 import java.util.Collections;
@@ -81,6 +83,7 @@ public class ShardsBatchGatewayAllocator implements ExistingShardsAllocator {
     private TimeValue primaryShardsBatchGatewayAllocatorTimeout;
     private TimeValue replicaShardsBatchGatewayAllocatorTimeout;
     public static final TimeValue MIN_ALLOCATOR_TIMEOUT = TimeValue.timeValueSeconds(20);
+    private final ClusterManagerMetrics clusterManagerMetrics;
 
     /**
      * Number of shards we send in one batch to data nodes for fetching metadata
@@ -160,7 +163,8 @@ public ShardsBatchGatewayAllocator(
         TransportNodesListGatewayStartedShardsBatch batchStartedAction,
         TransportNodesListShardStoreMetadataBatch batchStoreAction,
         Settings settings,
-        ClusterSettings clusterSettings
+        ClusterSettings clusterSettings,
+        ClusterManagerMetrics clusterManagerMetrics
     ) {
         this.rerouteService = rerouteService;
         this.primaryShardBatchAllocator = new InternalPrimaryBatchShardAllocator();
@@ -172,6 +176,7 @@ public ShardsBatchGatewayAllocator(
         clusterSettings.addSettingsUpdateConsumer(PRIMARY_BATCH_ALLOCATOR_TIMEOUT_SETTING, this::setPrimaryBatchAllocatorTimeout);
         this.replicaShardsBatchGatewayAllocatorTimeout = REPLICA_BATCH_ALLOCATOR_TIMEOUT_SETTING.get(settings);
         clusterSettings.addSettingsUpdateConsumer(REPLICA_BATCH_ALLOCATOR_TIMEOUT_SETTING, this::setReplicaBatchAllocatorTimeout);
+        this.clusterManagerMetrics = clusterManagerMetrics;
     }
 
     @Override
@@ -187,6 +192,7 @@ protected ShardsBatchGatewayAllocator() {
         this(DEFAULT_SHARD_BATCH_SIZE, null);
     }
 
+    // for tests
     protected ShardsBatchGatewayAllocator(long batchSize, RerouteService rerouteService) {
         this.rerouteService = rerouteService;
         this.batchStartedAction = null;
@@ -196,10 +202,9 @@ protected ShardsBatchGatewayAllocator(long batchSize, RerouteService rerouteServ
         this.maxBatchSize = batchSize;
         this.primaryShardsBatchGatewayAllocatorTimeout = null;
         this.replicaShardsBatchGatewayAllocatorTimeout = null;
+        this.clusterManagerMetrics = new ClusterManagerMetrics(NoopMetricsRegistry.INSTANCE);
     }
 
-    // for tests
-
     @Override
     public int getNumberOfInFlightFetches() {
         int count = 0;
@@ -413,7 +418,7 @@ else if (shardRouting.primary() == primary) {
             // add to batch if batch size full or last shard in unassigned list
             if (batchSize == 0 || iterator.hasNext() == false) {
                 String batchUUId = UUIDs.base64UUID();
-                ShardsBatch shardsBatch = new ShardsBatch(batchUUId, perBatchShards, primary);
+                ShardsBatch shardsBatch = new ShardsBatch(batchUUId, perBatchShards, primary, clusterManagerMetrics);
                 // add the batch to list of current batches
                 addBatch(shardsBatch, primary);
                 batchesToBeAssigned.add(batchUUId);
@@ -588,9 +593,21 @@ class InternalBatchAsyncFetch<T extends BaseNodeResponse, V> extends AsyncShardB
             Class<V> clazz,
             V emptyShardResponse,
             Predicate<V> emptyShardResponsePredicate,
-            ShardBatchResponseFactory<T, V> responseFactory
+            ShardBatchResponseFactory<T, V> responseFactory,
+            ClusterManagerMetrics clusterManagerMetrics
         ) {
-            super(logger, type, map, action, batchUUId, clazz, emptyShardResponse, emptyShardResponsePredicate, responseFactory);
+            super(
+                logger,
+                type,
+                map,
+                action,
+                batchUUId,
+                clazz,
+                emptyShardResponse,
+                emptyShardResponsePredicate,
+                responseFactory,
+                clusterManagerMetrics
+            );
         }
 
         @Override
@@ -650,16 +667,17 @@ protected boolean hasInitiatedFetching(ShardRouting shard) {
              * It should return false if there has never been a fetch for this batch.
              * This function is currently only used in the case of replica shards when all deciders returned NO/THROTTLE, and explain mode is ON.
              * Allocation explain and manual reroute APIs try to append shard store information (matching bytes) to the allocation decision.
-             * However, these APIs do not want to trigger a new asyncFetch for these ineligible shards, unless the data from nodes is already there.
+             * However, these APIs do not want to trigger a new asyncFetch for these ineligible shards
+             * They only want to use the data if it is already available.
              * This function is used to see if a fetch has happened to decide if it is possible to append shard store info without a new async fetch.
              * In the case when shard has a batch but no fetch has happened before, it would be because it is a new batch.
              * In the case when shard has a batch, and a fetch has happened before, and no fetch is ongoing, it would be because we have already completed fetch for all nodes.
-             *
+             * <p>
              * In order to check if a fetch has ever happened, we check 2 things:
              * 1. If the shard batch cache is empty, we know that fetch has never happened so we return false.
              * 2. If we see that the list of nodes to fetch from is empty, we know that all nodes have data or are ongoing a fetch. So we return true.
              * 3. Otherwise we return false.
-             *
+             * <p>
              * see {@link AsyncShardFetchCache#findNodesToFetch()}
              */
             String batchId = getBatchId(shard, shard.primary());
@@ -669,7 +687,8 @@ protected boolean hasInitiatedFetching(ShardRouting shard) {
             logger.trace("Checking if fetching done for batch id {}", batchId);
             ShardsBatch shardsBatch = shard.primary() ? batchIdToStartedShardBatch.get(batchId) : batchIdToStoreShardBatch.get(batchId);
             // if fetchData has never been called, the per node cache will be empty and have no nodes
-            // this is because cache.fillShardCacheWithDataNodes(nodes) initialises this map and is called in AsyncShardFetch.fetchData
+            /// this is because {@link AsyncShardFetchCache#fillShardCacheWithDataNodes(DiscoveryNodes)} initialises this map
+            /// and is called in {@link AsyncShardFetch#fetchData(DiscoveryNodes, Map)}
             if (shardsBatch == null || shardsBatch.getAsyncFetcher().hasEmptyCache()) {
                 logger.trace("Batch cache is empty for batch {} ", batchId);
                 return false;
@@ -739,7 +758,12 @@ public class ShardsBatch {
 
         private final Map<ShardId, ShardEntry> batchInfo;
 
-        public ShardsBatch(String batchId, Map<ShardId, ShardEntry> shardsWithInfo, boolean primary) {
+        public ShardsBatch(
+            String batchId,
+            Map<ShardId, ShardEntry> shardsWithInfo,
+            boolean primary,
+            ClusterManagerMetrics clusterManagerMetrics
+        ) {
             this.batchId = batchId;
             this.batchInfo = new HashMap<>(shardsWithInfo);
             // create a ShardId -> customDataPath map for async fetch
@@ -757,7 +781,8 @@ public ShardsBatch(String batchId, Map<ShardId, ShardEntry> shardsWithInfo, bool
                     GatewayStartedShard.class,
                     new GatewayStartedShard(null, false, null, null),
                     GatewayStartedShard::isEmpty,
-                    new ShardBatchResponseFactory<>(true)
+                    new ShardBatchResponseFactory<>(true),
+                    clusterManagerMetrics
                 );
             } else {
                 asyncBatch = new InternalBatchAsyncFetch<>(
@@ -769,7 +794,8 @@ public ShardsBatch(String batchId, Map<ShardId, ShardEntry> shardsWithInfo, bool
                     NodeStoreFilesMetadata.class,
                     new NodeStoreFilesMetadata(new StoreFilesMetadata(null, Store.MetadataSnapshot.EMPTY, Collections.emptyList()), null),
                     NodeStoreFilesMetadata::isEmpty,
-                    new ShardBatchResponseFactory<>(false)
+                    new ShardBatchResponseFactory<>(false),
+                    clusterManagerMetrics
                 );
             }
         }
diff --git a/server/src/main/java/org/opensearch/gateway/remote/ClusterStateChecksum.java b/server/src/main/java/org/opensearch/gateway/remote/ClusterStateChecksum.java
index d6739c4572d1a..aa007f5da15b3 100644
--- a/server/src/main/java/org/opensearch/gateway/remote/ClusterStateChecksum.java
+++ b/server/src/main/java/org/opensearch/gateway/remote/ClusterStateChecksum.java
@@ -12,8 +12,10 @@
 import org.apache.logging.log4j.Logger;
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.metadata.DiffableStringMap;
+import org.opensearch.common.CheckedFunction;
 import org.opensearch.common.io.stream.BytesStreamOutput;
 import org.opensearch.common.settings.Settings;
+import org.opensearch.common.unit.TimeValue;
 import org.opensearch.core.common.io.stream.BufferedChecksumStreamOutput;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
@@ -22,11 +24,15 @@
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.core.xcontent.XContentParseException;
 import org.opensearch.core.xcontent.XContentParser;
+import org.opensearch.threadpool.ThreadPool;
 
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.function.Consumer;
 
 import com.jcraft.jzlib.JZlib;
 
@@ -37,6 +43,7 @@
  */
 public class ClusterStateChecksum implements ToXContentFragment, Writeable {
 
+    public static final int COMPONENT_SIZE = 11;
     static final String ROUTING_TABLE_CS = "routing_table";
     static final String NODES_CS = "discovery_nodes";
     static final String BLOCKS_CS = "blocks";
@@ -65,62 +72,103 @@ public class ClusterStateChecksum implements ToXContentFragment, Writeable {
     long indicesChecksum;
     long clusterStateChecksum;
 
-    public ClusterStateChecksum(ClusterState clusterState) {
-        try (
-            BytesStreamOutput out = new BytesStreamOutput();
-            BufferedChecksumStreamOutput checksumOut = new BufferedChecksumStreamOutput(out)
-        ) {
-            clusterState.routingTable().writeVerifiableTo(checksumOut);
-            routingTableChecksum = checksumOut.getChecksum();
-
-            checksumOut.reset();
-            clusterState.nodes().writeVerifiableTo(checksumOut);
-            nodesChecksum = checksumOut.getChecksum();
-
-            checksumOut.reset();
-            clusterState.coordinationMetadata().writeVerifiableTo(checksumOut);
-            coordinationMetadataChecksum = checksumOut.getChecksum();
-
-            // Settings create sortedMap by default, so no explicit sorting required here.
-            checksumOut.reset();
-            Settings.writeSettingsToStream(clusterState.metadata().persistentSettings(), checksumOut);
-            settingMetadataChecksum = checksumOut.getChecksum();
-
-            checksumOut.reset();
-            Settings.writeSettingsToStream(clusterState.metadata().transientSettings(), checksumOut);
-            transientSettingsMetadataChecksum = checksumOut.getChecksum();
-
-            checksumOut.reset();
-            clusterState.metadata().templatesMetadata().writeVerifiableTo(checksumOut);
-            templatesMetadataChecksum = checksumOut.getChecksum();
-
-            checksumOut.reset();
-            checksumOut.writeStringCollection(clusterState.metadata().customs().keySet());
-            customMetadataMapChecksum = checksumOut.getChecksum();
-
-            checksumOut.reset();
-            ((DiffableStringMap) clusterState.metadata().hashesOfConsistentSettings()).writeTo(checksumOut);
-            hashesOfConsistentSettingsChecksum = checksumOut.getChecksum();
-
-            checksumOut.reset();
-            checksumOut.writeMapValues(
+    public ClusterStateChecksum(ClusterState clusterState, ThreadPool threadpool) {
+        long start = threadpool.relativeTimeInNanos();
+        ExecutorService executorService = threadpool.executor(ThreadPool.Names.REMOTE_STATE_CHECKSUM);
+        CountDownLatch latch = new CountDownLatch(COMPONENT_SIZE);
+
+        executeChecksumTask((stream) -> {
+            clusterState.routingTable().writeVerifiableTo(stream);
+            return null;
+        }, checksum -> routingTableChecksum = checksum, executorService, latch);
+
+        executeChecksumTask((stream) -> {
+            clusterState.nodes().writeVerifiableTo(stream);
+            return null;
+        }, checksum -> nodesChecksum = checksum, executorService, latch);
+
+        executeChecksumTask((stream) -> {
+            clusterState.coordinationMetadata().writeVerifiableTo(stream);
+            return null;
+        }, checksum -> coordinationMetadataChecksum = checksum, executorService, latch);
+
+        executeChecksumTask((stream) -> {
+            Settings.writeSettingsToStream(clusterState.metadata().persistentSettings(), stream);
+            return null;
+        }, checksum -> settingMetadataChecksum = checksum, executorService, latch);
+
+        executeChecksumTask((stream) -> {
+            Settings.writeSettingsToStream(clusterState.metadata().transientSettings(), stream);
+            return null;
+        }, checksum -> transientSettingsMetadataChecksum = checksum, executorService, latch);
+
+        executeChecksumTask((stream) -> {
+            clusterState.metadata().templatesMetadata().writeVerifiableTo(stream);
+            return null;
+        }, checksum -> templatesMetadataChecksum = checksum, executorService, latch);
+
+        executeChecksumTask((stream) -> {
+            stream.writeStringCollection(clusterState.metadata().customs().keySet());
+            return null;
+        }, checksum -> customMetadataMapChecksum = checksum, executorService, latch);
+
+        executeChecksumTask((stream) -> {
+            ((DiffableStringMap) clusterState.metadata().hashesOfConsistentSettings()).writeTo(stream);
+            return null;
+        }, checksum -> hashesOfConsistentSettingsChecksum = checksum, executorService, latch);
+
+        executeChecksumTask((stream) -> {
+            stream.writeMapValues(
                 clusterState.metadata().indices(),
-                (stream, value) -> value.writeVerifiableTo((BufferedChecksumStreamOutput) stream)
+                (checksumStream, value) -> value.writeVerifiableTo((BufferedChecksumStreamOutput) checksumStream)
             );
-            indicesChecksum = checksumOut.getChecksum();
-
-            checksumOut.reset();
-            clusterState.blocks().writeVerifiableTo(checksumOut);
-            blocksChecksum = checksumOut.getChecksum();
-
-            checksumOut.reset();
-            checksumOut.writeStringCollection(clusterState.customs().keySet());
-            clusterStateCustomsChecksum = checksumOut.getChecksum();
-        } catch (IOException e) {
-            logger.error("Failed to create checksum for cluster state.", e);
+            return null;
+        }, checksum -> indicesChecksum = checksum, executorService, latch);
+
+        executeChecksumTask((stream) -> {
+            clusterState.blocks().writeVerifiableTo(stream);
+            return null;
+        }, checksum -> blocksChecksum = checksum, executorService, latch);
+
+        executeChecksumTask((stream) -> {
+            stream.writeStringCollection(clusterState.customs().keySet());
+            return null;
+        }, checksum -> clusterStateCustomsChecksum = checksum, executorService, latch);
+
+        try {
+            latch.await();
+        } catch (InterruptedException e) {
             throw new RemoteStateTransferException("Failed to create checksum for cluster state.", e);
         }
         createClusterStateChecksum();
+        logger.debug("Checksum execution time {}", TimeValue.nsecToMSec(threadpool.relativeTimeInNanos() - start));
+    }
+
+    private void executeChecksumTask(
+        CheckedFunction<BufferedChecksumStreamOutput, Void, IOException> checksumTask,
+        Consumer<Long> checksumConsumer,
+        ExecutorService executorService,
+        CountDownLatch latch
+    ) {
+        executorService.execute(() -> {
+            try {
+                long checksum = createChecksum(checksumTask);
+                checksumConsumer.accept(checksum);
+                latch.countDown();
+            } catch (IOException e) {
+                throw new RemoteStateTransferException("Failed to execute checksum task", e);
+            }
+        });
+    }
+
+    private long createChecksum(CheckedFunction<BufferedChecksumStreamOutput, Void, IOException> task) throws IOException {
+        try (
+            BytesStreamOutput out = new BytesStreamOutput();
+            BufferedChecksumStreamOutput checksumOut = new BufferedChecksumStreamOutput(out)
+        ) {
+            task.apply(checksumOut);
+            return checksumOut.getChecksum();
+        }
     }
 
     private void createClusterStateChecksum() {
diff --git a/server/src/main/java/org/opensearch/gateway/remote/RemoteClusterStateService.java b/server/src/main/java/org/opensearch/gateway/remote/RemoteClusterStateService.java
index ece29180f9cf5..1d7200792442f 100644
--- a/server/src/main/java/org/opensearch/gateway/remote/RemoteClusterStateService.java
+++ b/server/src/main/java/org/opensearch/gateway/remote/RemoteClusterStateService.java
@@ -111,7 +111,7 @@
 import static org.opensearch.gateway.remote.model.RemoteTemplatesMetadata.TEMPLATES_METADATA;
 import static org.opensearch.gateway.remote.model.RemoteTransientSettingsMetadata.TRANSIENT_SETTING_METADATA;
 import static org.opensearch.gateway.remote.routingtable.RemoteIndexRoutingTable.INDEX_ROUTING_METADATA_PREFIX;
-import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.isRemoteStoreClusterStateEnabled;
+import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.isRemoteClusterStateConfigured;
 
 /**
  * A Service which provides APIs to upload and download cluster metadata from remote store.
@@ -256,7 +256,7 @@ public RemoteClusterStateService(
         List<IndexMetadataUploadListener> indexMetadataUploadListeners,
         NamedWriteableRegistry namedWriteableRegistry
     ) {
-        assert isRemoteStoreClusterStateEnabled(settings) : "Remote cluster state is not enabled";
+        assert isRemoteClusterStateConfigured(settings) : "Remote cluster state is not configured";
         this.nodeId = nodeId;
         this.repositoriesService = repositoriesService;
         this.settings = settings;
@@ -332,7 +332,9 @@ public RemoteClusterStateManifestInfo writeFullMetadata(ClusterState clusterStat
             uploadedMetadataResults,
             previousClusterUUID,
             clusterStateDiffManifest,
-            !remoteClusterStateValidationMode.equals(RemoteClusterStateValidationMode.NONE) ? new ClusterStateChecksum(clusterState) : null,
+            !remoteClusterStateValidationMode.equals(RemoteClusterStateValidationMode.NONE)
+                ? new ClusterStateChecksum(clusterState, threadpool)
+                : null,
             false,
             codecVersion
         );
@@ -539,7 +541,9 @@ public RemoteClusterStateManifestInfo writeIncrementalMetadata(
             uploadedMetadataResults,
             previousManifest.getPreviousClusterUUID(),
             clusterStateDiffManifest,
-            !remoteClusterStateValidationMode.equals(RemoteClusterStateValidationMode.NONE) ? new ClusterStateChecksum(clusterState) : null,
+            !remoteClusterStateValidationMode.equals(RemoteClusterStateValidationMode.NONE)
+                ? new ClusterStateChecksum(clusterState, threadpool)
+                : null,
             false,
             previousManifest.getCodecVersion()
         );
@@ -1010,7 +1014,9 @@ public RemoteClusterStateManifestInfo markLastStateAsCommitted(
             uploadedMetadataResults,
             previousManifest.getPreviousClusterUUID(),
             previousManifest.getDiffManifest(),
-            !remoteClusterStateValidationMode.equals(RemoteClusterStateValidationMode.NONE) ? new ClusterStateChecksum(clusterState) : null,
+            !remoteClusterStateValidationMode.equals(RemoteClusterStateValidationMode.NONE)
+                ? new ClusterStateChecksum(clusterState, threadpool)
+                : null,
             true,
             previousManifest.getCodecVersion()
         );
@@ -1055,7 +1061,7 @@ public void close() throws IOException {
     }
 
     public void start() {
-        assert isRemoteStoreClusterStateEnabled(settings) == true : "Remote cluster state is not enabled";
+        assert isRemoteClusterStateConfigured(settings) == true : "Remote cluster state is not enabled";
         final String remoteStoreRepo = settings.get(
             Node.NODE_ATTRIBUTES.getKey() + RemoteStoreNodeAttribute.REMOTE_STORE_CLUSTER_STATE_REPOSITORY_NAME_ATTRIBUTE_KEY
         );
@@ -1631,7 +1637,7 @@ void validateClusterStateFromChecksum(
         String localNodeId,
         boolean isFullStateDownload
     ) {
-        ClusterStateChecksum newClusterStateChecksum = new ClusterStateChecksum(clusterState);
+        ClusterStateChecksum newClusterStateChecksum = new ClusterStateChecksum(clusterState, threadpool);
         List<String> failedValidation = newClusterStateChecksum.getMismatchEntities(manifest.getClusterStateChecksum());
         if (failedValidation.isEmpty()) {
             return;
diff --git a/server/src/main/java/org/opensearch/identity/IdentityService.java b/server/src/main/java/org/opensearch/identity/IdentityService.java
index 03f937180f4ba..33066fae5a80d 100644
--- a/server/src/main/java/org/opensearch/identity/IdentityService.java
+++ b/server/src/main/java/org/opensearch/identity/IdentityService.java
@@ -8,6 +8,7 @@
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.opensearch.OpenSearchException;
+import org.opensearch.common.annotation.InternalApi;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.identity.noop.NoopIdentityPlugin;
 import org.opensearch.identity.tokens.TokenManager;
@@ -22,8 +23,9 @@
 /**
  * Identity and access control for OpenSearch
  *
- * @opensearch.experimental
+ * @opensearch.internal
  * */
+@InternalApi
 public class IdentityService {
     private static final Logger log = LogManager.getLogger(IdentityService.class);
 
diff --git a/server/src/main/java/org/opensearch/index/remote/RemoteIndexPathUploader.java b/server/src/main/java/org/opensearch/index/remote/RemoteIndexPathUploader.java
index 5878dff03acc2..2a76a5b966884 100644
--- a/server/src/main/java/org/opensearch/index/remote/RemoteIndexPathUploader.java
+++ b/server/src/main/java/org/opensearch/index/remote/RemoteIndexPathUploader.java
@@ -51,8 +51,8 @@
 import static org.opensearch.index.remote.RemoteIndexPath.SEGMENT_PATH;
 import static org.opensearch.index.remote.RemoteIndexPath.TRANSLOG_PATH;
 import static org.opensearch.index.remote.RemoteStoreUtils.determineRemoteStorePathStrategy;
+import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.isRemoteClusterStateConfigured;
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.isRemoteDataAttributePresent;
-import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.isRemoteStoreClusterStateEnabled;
 
 /**
  * Uploads the remote store path for all possible combinations of {@link org.opensearch.index.remote.RemoteStoreEnums.DataCategory}
@@ -235,7 +235,7 @@ private Repository validateAndGetRepository(String repoSetting) {
     }
 
     public void start() {
-        assert isRemoteStoreClusterStateEnabled(settings) == true : "Remote cluster state is not enabled";
+        assert isRemoteClusterStateConfigured(settings) == true : "Remote cluster state is not configured";
         if (isRemoteDataAttributePresent == false) {
             // If remote store data attributes are not present than we skip this.
             return;
diff --git a/server/src/main/java/org/opensearch/index/translog/RemoteFsTimestampAwareTranslog.java b/server/src/main/java/org/opensearch/index/translog/RemoteFsTimestampAwareTranslog.java
index e61a9606175ee..ede422ea3c4f7 100644
--- a/server/src/main/java/org/opensearch/index/translog/RemoteFsTimestampAwareTranslog.java
+++ b/server/src/main/java/org/opensearch/index/translog/RemoteFsTimestampAwareTranslog.java
@@ -121,7 +121,7 @@ public void trimUnreferencedReaders() throws IOException {
     protected void trimUnreferencedReaders(boolean indexDeleted, boolean trimLocal) throws IOException {
         if (trimLocal) {
             // clean up local translog files and updates readers
-            super.trimUnreferencedReaders();
+            super.trimUnreferencedReaders(true);
         }
 
         // Update file tracker to reflect local translog state
diff --git a/server/src/main/java/org/opensearch/index/translog/RemoteFsTranslog.java b/server/src/main/java/org/opensearch/index/translog/RemoteFsTranslog.java
index 80760ed6ddf12..f5a9ed8ed9362 100644
--- a/server/src/main/java/org/opensearch/index/translog/RemoteFsTranslog.java
+++ b/server/src/main/java/org/opensearch/index/translog/RemoteFsTranslog.java
@@ -556,9 +556,17 @@ protected Releasable drainSync() {
 
     @Override
     public void trimUnreferencedReaders() throws IOException {
+        trimUnreferencedReaders(false);
+    }
+
+    protected void trimUnreferencedReaders(boolean onlyTrimLocal) throws IOException {
         // clean up local translog files and updates readers
         super.trimUnreferencedReaders();
 
+        if (onlyTrimLocal) {
+            return;
+        }
+
         // This is to ensure that after the permits are acquired during primary relocation, there are no further modification on remote
         // store.
         if (startedPrimarySupplier.getAsBoolean() == false || pauseSync.get()) {
diff --git a/server/src/main/java/org/opensearch/node/Node.java b/server/src/main/java/org/opensearch/node/Node.java
index 4962d72d8728a..fe4bfa1e64ba1 100644
--- a/server/src/main/java/org/opensearch/node/Node.java
+++ b/server/src/main/java/org/opensearch/node/Node.java
@@ -311,9 +311,9 @@
 import static org.opensearch.env.NodeEnvironment.collectFileCacheDataPath;
 import static org.opensearch.index.ShardIndexingPressureSettings.SHARD_INDEXING_PRESSURE_ENABLED_ATTRIBUTE_KEY;
 import static org.opensearch.indices.RemoteStoreSettings.CLUSTER_REMOTE_STORE_PINNED_TIMESTAMP_ENABLED;
+import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.isRemoteClusterStateConfigured;
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.isRemoteDataAttributePresent;
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.isRemoteStoreAttributePresent;
-import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.isRemoteStoreClusterStateEnabled;
 
 /**
  * A node represent a node within a cluster ({@code cluster.name}). The {@link #client()} can be used
@@ -526,11 +526,7 @@ protected Node(
             FeatureFlags.initializeFeatureFlags(settings);
 
             final List<IdentityPlugin> identityPlugins = new ArrayList<>();
-            if (FeatureFlags.isEnabled(FeatureFlags.IDENTITY)) {
-                // If identity is enabled load plugins implementing the extension point
-                logger.info("Identity on so found plugins implementing: " + pluginsService.filterPlugins(IdentityPlugin.class).toString());
-                identityPlugins.addAll(pluginsService.filterPlugins(IdentityPlugin.class));
-            }
+            identityPlugins.addAll(pluginsService.filterPlugins(IdentityPlugin.class));
 
             final Set<DiscoveryNodeRole> additionalRoles = pluginsService.filterPlugins(Plugin.class)
                 .stream()
@@ -796,7 +792,7 @@ protected Node(
             final RemoteClusterStateService remoteClusterStateService;
             final RemoteClusterStateCleanupManager remoteClusterStateCleanupManager;
             final RemoteIndexPathUploader remoteIndexPathUploader;
-            if (isRemoteStoreClusterStateEnabled(settings)) {
+            if (isRemoteClusterStateConfigured(settings)) {
                 remoteIndexPathUploader = new RemoteIndexPathUploader(
                     threadPool,
                     settings,
diff --git a/server/src/main/java/org/opensearch/node/NodeService.java b/server/src/main/java/org/opensearch/node/NodeService.java
index 1eb38ea63ad5a..9671fda14375d 100644
--- a/server/src/main/java/org/opensearch/node/NodeService.java
+++ b/server/src/main/java/org/opensearch/node/NodeService.java
@@ -54,6 +54,7 @@
 import org.opensearch.indices.IndicesService;
 import org.opensearch.ingest.IngestService;
 import org.opensearch.monitor.MonitorService;
+import org.opensearch.node.remotestore.RemoteStoreNodeStats;
 import org.opensearch.plugins.PluginsService;
 import org.opensearch.ratelimitting.admissioncontrol.AdmissionControlService;
 import org.opensearch.repositories.RepositoriesService;
@@ -241,7 +242,8 @@ public NodeStats stats(
         boolean segmentReplicationTrackerStats,
         boolean repositoriesStats,
         boolean admissionControl,
-        boolean cacheService
+        boolean cacheService,
+        boolean remoteStoreNodeStats
     ) {
         // for indices stats we want to include previous allocated shards stats as well (it will
         // only be applied to the sensible ones to use, like refresh/merge/flush/indexing stats)
@@ -274,7 +276,8 @@ public NodeStats stats(
             segmentReplicationTrackerStats ? this.segmentReplicationStatsTracker.getTotalRejectionStats() : null,
             repositoriesStats ? this.repositoriesService.getRepositoriesStats() : null,
             admissionControl ? this.admissionControlService.stats() : null,
-            cacheService ? this.cacheService.stats(indices) : null
+            cacheService ? this.cacheService.stats(indices) : null,
+            remoteStoreNodeStats ? new RemoteStoreNodeStats() : null
         );
     }
 
diff --git a/server/src/main/java/org/opensearch/node/remotestore/RemoteStoreNodeAttribute.java b/server/src/main/java/org/opensearch/node/remotestore/RemoteStoreNodeAttribute.java
index 55971398634c5..d6a58f8e1d471 100644
--- a/server/src/main/java/org/opensearch/node/remotestore/RemoteStoreNodeAttribute.java
+++ b/server/src/main/java/org/opensearch/node/remotestore/RemoteStoreNodeAttribute.java
@@ -180,7 +180,7 @@ public static boolean isRemoteDataAttributePresent(Settings settings) {
             || settings.getByPrefix(Node.NODE_ATTRIBUTES.getKey() + REMOTE_STORE_TRANSLOG_REPOSITORY_NAME_ATTRIBUTE_KEY).isEmpty() == false;
     }
 
-    public static boolean isRemoteClusterStateAttributePresent(Settings settings) {
+    public static boolean isRemoteClusterStateConfigured(Settings settings) {
         return settings.getByPrefix(Node.NODE_ATTRIBUTES.getKey() + REMOTE_STORE_CLUSTER_STATE_REPOSITORY_NAME_ATTRIBUTE_KEY)
             .isEmpty() == false;
     }
@@ -194,8 +194,7 @@ public static String getRemoteStoreTranslogRepo(Settings settings) {
     }
 
     public static boolean isRemoteStoreClusterStateEnabled(Settings settings) {
-        return RemoteClusterStateService.REMOTE_CLUSTER_STATE_ENABLED_SETTING.get(settings)
-            && isRemoteClusterStateAttributePresent(settings);
+        return RemoteClusterStateService.REMOTE_CLUSTER_STATE_ENABLED_SETTING.get(settings) && isRemoteClusterStateConfigured(settings);
     }
 
     private static boolean isRemoteRoutingTableAttributePresent(Settings settings) {
diff --git a/server/src/main/java/org/opensearch/node/remotestore/RemoteStoreNodeStats.java b/server/src/main/java/org/opensearch/node/remotestore/RemoteStoreNodeStats.java
new file mode 100644
index 0000000000000..8da8a17e21839
--- /dev/null
+++ b/server/src/main/java/org/opensearch/node/remotestore/RemoteStoreNodeStats.java
@@ -0,0 +1,79 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.node.remotestore;
+
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.common.io.stream.StreamOutput;
+import org.opensearch.core.common.io.stream.Writeable;
+import org.opensearch.core.xcontent.ToXContentFragment;
+import org.opensearch.core.xcontent.XContentBuilder;
+
+import java.io.IOException;
+import java.util.Objects;
+
+/**
+ * Node level remote store stats
+ * @opensearch.internal
+ */
+public class RemoteStoreNodeStats implements Writeable, ToXContentFragment {
+
+    public static final String STATS_NAME = "remote_store";
+    public static final String LAST_SUCCESSFUL_FETCH_OF_PINNED_TIMESTAMPS = "last_successful_fetch_of_pinned_timestamps";
+
+    /**
+     * Time stamp for the last successful fetch of pinned timestamps by the {@linkplain  RemoteStorePinnedTimestampService}
+     */
+    private final long lastSuccessfulFetchOfPinnedTimestamps;
+
+    public RemoteStoreNodeStats() {
+        this.lastSuccessfulFetchOfPinnedTimestamps = RemoteStorePinnedTimestampService.getPinnedTimestamps().v1();
+    }
+
+    public long getLastSuccessfulFetchOfPinnedTimestamps() {
+        return this.lastSuccessfulFetchOfPinnedTimestamps;
+    }
+
+    public RemoteStoreNodeStats(StreamInput in) throws IOException {
+        this.lastSuccessfulFetchOfPinnedTimestamps = in.readLong();
+    }
+
+    @Override
+    public void writeTo(StreamOutput out) throws IOException {
+        out.writeLong(this.lastSuccessfulFetchOfPinnedTimestamps);
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject(STATS_NAME);
+        builder.field(LAST_SUCCESSFUL_FETCH_OF_PINNED_TIMESTAMPS, this.lastSuccessfulFetchOfPinnedTimestamps);
+        return builder.endObject();
+    }
+
+    @Override
+    public String toString() {
+        return "RemoteStoreNodeStats{ lastSuccessfulFetchOfPinnedTimestamps=" + lastSuccessfulFetchOfPinnedTimestamps + "}";
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (o == null) {
+            return false;
+        }
+        if (o.getClass() != RemoteStoreNodeStats.class) {
+            return false;
+        }
+        RemoteStoreNodeStats other = (RemoteStoreNodeStats) o;
+        return this.lastSuccessfulFetchOfPinnedTimestamps == other.lastSuccessfulFetchOfPinnedTimestamps;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(lastSuccessfulFetchOfPinnedTimestamps);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/node/remotestore/RemoteStorePinnedTimestampService.java b/server/src/main/java/org/opensearch/node/remotestore/RemoteStorePinnedTimestampService.java
index 1448c46583f6a..a3382d8568ec5 100644
--- a/server/src/main/java/org/opensearch/node/remotestore/RemoteStorePinnedTimestampService.java
+++ b/server/src/main/java/org/opensearch/node/remotestore/RemoteStorePinnedTimestampService.java
@@ -30,6 +30,9 @@
 import java.io.ByteArrayInputStream;
 import java.io.Closeable;
 import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
@@ -49,6 +52,7 @@
 public class RemoteStorePinnedTimestampService implements Closeable {
     private static final Logger logger = LogManager.getLogger(RemoteStorePinnedTimestampService.class);
     private static Tuple<Long, Set<Long>> pinnedTimestampsSet = new Tuple<>(-1L, Set.of());
+    private static Map<String, List<Long>> pinnedEntityToTimestampsMap = new HashMap<>();
     public static final String PINNED_TIMESTAMPS_PATH_TOKEN = "pinned_timestamps";
     public static final String PINNED_TIMESTAMPS_FILENAME_SEPARATOR = "__";
 
@@ -216,6 +220,16 @@ private long getTimestampFromBlobName(String blobName) {
         return -1;
     }
 
+    private String getEntityFromBlobName(String blobName) {
+        String[] blobNameTokens = blobName.split(PINNED_TIMESTAMPS_FILENAME_SEPARATOR);
+        if (blobNameTokens.length < 2) {
+            String errorMessage = "Pinned timestamps blob name contains invalid format: " + blobName;
+            logger.error(errorMessage);
+            throw new IllegalArgumentException(errorMessage);
+        }
+        return String.join(PINNED_TIMESTAMPS_FILENAME_SEPARATOR, Arrays.copyOfRange(blobNameTokens, 0, blobNameTokens.length - 1));
+    }
+
     /**
      * Unpins a timestamp from the remote store.
      *
@@ -262,6 +276,10 @@ public static Tuple<Long, Set<Long>> getPinnedTimestamps() {
         return pinnedTimestampsSet;
     }
 
+    public static Map<String, List<Long>> getPinnedEntities() {
+        return pinnedEntityToTimestampsMap;
+    }
+
     /**
      * Inner class for asynchronously updating the pinned timestamp set.
      */
@@ -283,6 +301,7 @@ protected void runInternal() {
                 Map<String, BlobMetadata> pinnedTimestampList = blobContainer.listBlobs();
                 if (pinnedTimestampList.isEmpty()) {
                     pinnedTimestampsSet = new Tuple<>(triggerTimestamp, Set.of());
+                    pinnedEntityToTimestampsMap = new HashMap<>();
                     return;
                 }
                 Set<Long> pinnedTimestamps = pinnedTimestampList.keySet()
@@ -290,8 +309,19 @@ protected void runInternal() {
                     .map(RemoteStorePinnedTimestampService.this::getTimestampFromBlobName)
                     .filter(timestamp -> timestamp != -1)
                     .collect(Collectors.toSet());
+
                 logger.debug("Fetched pinned timestamps from remote store: {} - {}", triggerTimestamp, pinnedTimestamps);
                 pinnedTimestampsSet = new Tuple<>(triggerTimestamp, pinnedTimestamps);
+                pinnedEntityToTimestampsMap = pinnedTimestampList.keySet()
+                    .stream()
+                    .collect(Collectors.toMap(RemoteStorePinnedTimestampService.this::getEntityFromBlobName, blobName -> {
+                        long timestamp = RemoteStorePinnedTimestampService.this.getTimestampFromBlobName(blobName);
+                        return Collections.singletonList(timestamp);
+                    }, (existingList, newList) -> {
+                        List<Long> mergedList = new ArrayList<>(existingList);
+                        mergedList.addAll(newList);
+                        return mergedList;
+                    }));
             } catch (Throwable t) {
                 logger.error("Exception while fetching pinned timestamp details", t);
             }
diff --git a/server/src/main/java/org/opensearch/repositories/Repository.java b/server/src/main/java/org/opensearch/repositories/Repository.java
index d4520beb5b570..138bc13140aea 100644
--- a/server/src/main/java/org/opensearch/repositories/Repository.java
+++ b/server/src/main/java/org/opensearch/repositories/Repository.java
@@ -180,7 +180,7 @@ void finalizeSnapshot(
      * @param repositoryUpdatePriority  priority for the cluster state update task
      * @param listener              listener to be invoked with the new {@link RepositoryData} after completing the snapshot
      */
-    void finalizeSnapshot(
+    default void finalizeSnapshot(
         ShardGenerations shardGenerations,
         long repositoryStateId,
         Metadata clusterMetadata,
@@ -189,7 +189,9 @@ void finalizeSnapshot(
         Function<ClusterState, ClusterState> stateTransformer,
         Priority repositoryUpdatePriority,
         ActionListener<RepositoryData> listener
-    );
+    ) {
+        throw new UnsupportedOperationException();
+    }
 
     /**
      * Deletes snapshots
diff --git a/server/src/main/java/org/opensearch/rest/RestController.java b/server/src/main/java/org/opensearch/rest/RestController.java
index 4f87c01258396..c17f723c13f2a 100644
--- a/server/src/main/java/org/opensearch/rest/RestController.java
+++ b/server/src/main/java/org/opensearch/rest/RestController.java
@@ -709,7 +709,7 @@ public void sendResponse(RestResponse response) {
                 prepareResponse(response.status(), Map.of("Content-Type", List.of(response.contentType())));
             }
 
-            Mono.ignoreElements(this).then(Mono.just(response)).subscribe(delegate::sendResponse);
+            Mono.from(this).ignoreElement().then(Mono.just(response)).subscribe(delegate::sendResponse);
         }
 
         @Override
diff --git a/server/src/main/java/org/opensearch/rest/RestHandler.java b/server/src/main/java/org/opensearch/rest/RestHandler.java
index 1139e5fc65f31..7c3a369be61b9 100644
--- a/server/src/main/java/org/opensearch/rest/RestHandler.java
+++ b/server/src/main/java/org/opensearch/rest/RestHandler.java
@@ -125,6 +125,13 @@ default boolean allowSystemIndexAccessByDefault() {
         return false;
     }
 
+    /**
+     * Denotes whether the RestHandler will output paginated responses or not.
+     */
+    default boolean isActionPaginated() {
+        return false;
+    }
+
     static RestHandler wrapper(RestHandler delegate) {
         return new Wrapper(delegate);
     }
@@ -185,6 +192,16 @@ public List<ReplacedRoute> replacedRoutes() {
         public boolean allowSystemIndexAccessByDefault() {
             return delegate.allowSystemIndexAccessByDefault();
         }
+
+        @Override
+        public boolean isActionPaginated() {
+            return delegate.isActionPaginated();
+        }
+
+        @Override
+        public boolean supportsStreaming() {
+            return delegate.supportsStreaming();
+        }
     }
 
     /**
diff --git a/server/src/main/java/org/opensearch/rest/RestRequest.java b/server/src/main/java/org/opensearch/rest/RestRequest.java
index 2c397f7fc6e8e..f241b567c3204 100644
--- a/server/src/main/java/org/opensearch/rest/RestRequest.java
+++ b/server/src/main/java/org/opensearch/rest/RestRequest.java
@@ -51,6 +51,7 @@
 import org.opensearch.core.xcontent.XContentParser;
 import org.opensearch.http.HttpChannel;
 import org.opensearch.http.HttpRequest;
+import org.opensearch.rest.pagination.PageParams;
 
 import java.io.IOException;
 import java.io.InputStream;
@@ -67,6 +68,9 @@
 
 import static org.opensearch.common.unit.TimeValue.parseTimeValue;
 import static org.opensearch.core.common.unit.ByteSizeValue.parseBytesSizeValue;
+import static org.opensearch.rest.pagination.PageParams.PARAM_NEXT_TOKEN;
+import static org.opensearch.rest.pagination.PageParams.PARAM_SIZE;
+import static org.opensearch.rest.pagination.PageParams.PARAM_SORT;
 
 /**
  * REST Request
@@ -591,6 +595,10 @@ public static MediaType parseContentType(List<String> header) {
         throw new IllegalArgumentException("empty Content-Type header");
     }
 
+    public PageParams parsePaginatedQueryParams(String defaultSortOrder, int defaultPageSize) {
+        return new PageParams(param(PARAM_NEXT_TOKEN), param(PARAM_SORT, defaultSortOrder), paramAsInt(PARAM_SIZE, defaultPageSize));
+    }
+
     /**
      * Thrown if there is an error in the content type header.
      *
diff --git a/server/src/main/java/org/opensearch/rest/action/cat/AbstractCatAction.java b/server/src/main/java/org/opensearch/rest/action/cat/AbstractCatAction.java
index 6f4e060363bfb..506f5f1529776 100644
--- a/server/src/main/java/org/opensearch/rest/action/cat/AbstractCatAction.java
+++ b/server/src/main/java/org/opensearch/rest/action/cat/AbstractCatAction.java
@@ -33,6 +33,7 @@
 
 import org.opensearch.client.node.NodeClient;
 import org.opensearch.common.Table;
+import org.opensearch.common.breaker.ResponseLimitSettings;
 import org.opensearch.common.io.Streams;
 import org.opensearch.common.io.UTF8StreamWriter;
 import org.opensearch.core.common.io.stream.BytesStream;
@@ -98,4 +99,12 @@ protected Set<String> responseParams() {
         return RESPONSE_PARAMS;
     }
 
+    /**
+     * Method to check if limits defined in {@link ResponseLimitSettings} are applicable to an action.
+     *
+     * @return True / False status
+     */
+    protected boolean isRequestLimitCheckSupported() {
+        return false;
+    }
 }
diff --git a/server/src/main/java/org/opensearch/rest/action/cat/RestIndicesAction.java b/server/src/main/java/org/opensearch/rest/action/cat/RestIndicesAction.java
index 9dc711f804144..7562e09ddd704 100644
--- a/server/src/main/java/org/opensearch/rest/action/cat/RestIndicesAction.java
+++ b/server/src/main/java/org/opensearch/rest/action/cat/RestIndicesAction.java
@@ -50,6 +50,9 @@
 import org.opensearch.cluster.health.ClusterIndexHealth;
 import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.common.Table;
+import org.opensearch.common.breaker.ResponseLimitBreachedException;
+import org.opensearch.common.breaker.ResponseLimitSettings;
+import org.opensearch.common.collect.Tuple;
 import org.opensearch.common.logging.DeprecationLogger;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.time.DateFormatter;
@@ -61,6 +64,9 @@
 import org.opensearch.rest.RestRequest;
 import org.opensearch.rest.RestResponse;
 import org.opensearch.rest.action.RestResponseListener;
+import org.opensearch.rest.action.list.AbstractListAction;
+import org.opensearch.rest.pagination.IndexPaginationStrategy;
+import org.opensearch.rest.pagination.PageToken;
 
 import java.time.Instant;
 import java.time.ZoneOffset;
@@ -68,9 +74,11 @@
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashSet;
+import java.util.Iterator;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Set;
 import java.util.Spliterators;
 import java.util.function.Function;
@@ -80,6 +88,7 @@
 import static java.util.Arrays.asList;
 import static java.util.Collections.unmodifiableList;
 import static org.opensearch.action.support.clustermanager.ClusterManagerNodeRequest.DEFAULT_CLUSTER_MANAGER_NODE_TIMEOUT;
+import static org.opensearch.common.breaker.ResponseLimitSettings.LimitEntity.INDICES;
 import static org.opensearch.rest.RestRequest.Method.GET;
 
 /**
@@ -87,7 +96,7 @@
  *
  * @opensearch.api
  */
-public class RestIndicesAction extends AbstractCatAction {
+public class RestIndicesAction extends AbstractListAction {
 
     private static final DateFormatter STRICT_DATE_TIME_FORMATTER = DateFormatter.forPattern("strict_date_time");
     private static final DeprecationLogger deprecationLogger = DeprecationLogger.getLogger(RestIndicesAction.class);
@@ -96,6 +105,12 @@ public class RestIndicesAction extends AbstractCatAction {
     private static final String DUPLICATE_PARAMETER_ERROR_MESSAGE =
         "Please only use one of the request parameters [master_timeout, cluster_manager_timeout].";
 
+    private final ResponseLimitSettings responseLimitSettings;
+
+    public RestIndicesAction(ResponseLimitSettings responseLimitSettings) {
+        this.responseLimitSettings = responseLimitSettings;
+    }
+
     @Override
     public List<Route> routes() {
         return unmodifiableList(asList(new Route(GET, "/_cat/indices"), new Route(GET, "/_cat/indices/{index}")));
@@ -117,6 +132,11 @@ protected void documentation(StringBuilder sb) {
         sb.append("/_cat/indices/{index}\n");
     }
 
+    @Override
+    public boolean isRequestLimitCheckSupported() {
+        return true;
+    }
+
     @Override
     public RestChannelConsumer doCatRequest(final RestRequest request, final NodeClient client) {
         final String[] indices = Strings.splitStringByCommaToArray(request.param("index"));
@@ -151,48 +171,70 @@ public RestResponse buildResponse(final Table table) throws Exception {
                 new ActionListener<GetSettingsResponse>() {
                     @Override
                     public void onResponse(final GetSettingsResponse getSettingsResponse) {
-                        final GroupedActionListener<ActionResponse> groupedListener = createGroupedListener(request, 4, listener);
-                        groupedListener.onResponse(getSettingsResponse);
-
                         // The list of indices that will be returned is determined by the indices returned from the Get Settings call.
                         // All the other requests just provide additional detail, and wildcards may be resolved differently depending on the
                         // type of request in the presence of security plugins (looking at you, ClusterHealthRequest), so
                         // force the IndicesOptions for all the sub-requests to be as inclusive as possible.
                         final IndicesOptions subRequestIndicesOptions = IndicesOptions.lenientExpandHidden();
-
-                        // Indices that were successfully resolved during the get settings request might be deleted when the subsequent
-                        // cluster
-                        // state, cluster health and indices stats requests execute. We have to distinguish two cases:
-                        // 1) the deleted index was explicitly passed as parameter to the /_cat/indices request. In this case we want the
-                        // subsequent requests to fail.
-                        // 2) the deleted index was resolved as part of a wildcard or _all. In this case, we want the subsequent requests
-                        // not to
-                        // fail on the deleted index (as we want to ignore wildcards that cannot be resolved).
-                        // This behavior can be ensured by letting the cluster state, cluster health and indices stats requests re-resolve
-                        // the
-                        // index names with the same indices options that we used for the initial cluster state request (strictExpand).
-                        sendIndicesStatsRequest(
-                            indices,
-                            subRequestIndicesOptions,
-                            includeUnloadedSegments,
-                            client,
-                            ActionListener.wrap(groupedListener::onResponse, groupedListener::onFailure)
-                        );
+                        // Indices that were successfully resolved during the get settings request might be deleted when the
+                        // subsequent cluster state, cluster health and indices stats requests execute. We have to distinguish two cases:
+                        // 1) the deleted index was explicitly passed as parameter to the /_cat/indices request. In this case we
+                        // want the subsequent requests to fail.
+                        // 2) the deleted index was resolved as part of a wildcard or _all. In this case, we want the subsequent
+                        // requests not to fail on the deleted index (as we want to ignore wildcards that cannot be resolved).
+                        // This behavior can be ensured by letting the cluster state, cluster health and indices stats requests
+                        // re-resolve the index names with the same indices options that we used for the initial cluster state
+                        // request (strictExpand).
                         sendClusterStateRequest(
                             indices,
                             subRequestIndicesOptions,
                             local,
                             clusterManagerNodeTimeout,
                             client,
-                            ActionListener.wrap(groupedListener::onResponse, groupedListener::onFailure)
-                        );
-                        sendClusterHealthRequest(
-                            indices,
-                            subRequestIndicesOptions,
-                            local,
-                            clusterManagerNodeTimeout,
-                            client,
-                            ActionListener.wrap(groupedListener::onResponse, groupedListener::onFailure)
+                            new ActionListener<ClusterStateResponse>() {
+                                @Override
+                                public void onResponse(ClusterStateResponse clusterStateResponse) {
+                                    validateRequestLimit(clusterStateResponse, listener);
+                                    IndexPaginationStrategy paginationStrategy = getPaginationStrategy(clusterStateResponse);
+                                    // For non-paginated queries, indicesToBeQueried would be same as indices retrieved from
+                                    // rest request and unresolved, while for paginated queries, it would be a list of indices
+                                    // already resolved by ClusterStateRequest and to be displayed in a page.
+                                    final String[] indicesToBeQueried = Objects.isNull(paginationStrategy)
+                                        ? indices
+                                        : paginationStrategy.getRequestedEntities().toArray(new String[0]);
+                                    final GroupedActionListener<ActionResponse> groupedListener = createGroupedListener(
+                                        request,
+                                        4,
+                                        listener,
+                                        indicesToBeQueried,
+                                        Objects.isNull(paginationStrategy) ? null : paginationStrategy.getResponseToken()
+                                    );
+                                    groupedListener.onResponse(getSettingsResponse);
+                                    groupedListener.onResponse(clusterStateResponse);
+
+                                    sendIndicesStatsRequest(
+                                        indicesToBeQueried,
+                                        subRequestIndicesOptions,
+                                        includeUnloadedSegments,
+                                        client,
+                                        ActionListener.wrap(groupedListener::onResponse, groupedListener::onFailure)
+                                    );
+
+                                    sendClusterHealthRequest(
+                                        indicesToBeQueried,
+                                        subRequestIndicesOptions,
+                                        local,
+                                        clusterManagerNodeTimeout,
+                                        client,
+                                        ActionListener.wrap(groupedListener::onResponse, groupedListener::onFailure)
+                                    );
+                                }
+
+                                @Override
+                                public void onFailure(Exception e) {
+                                    listener.onFailure(e);
+                                }
+                            }
                         );
                     }
 
@@ -203,6 +245,16 @@ public void onFailure(final Exception e) {
                 }
             );
         };
+
+    }
+
+    private void validateRequestLimit(final ClusterStateResponse clusterStateResponse, final ActionListener<Table> listener) {
+        if (isRequestLimitCheckSupported() && Objects.nonNull(clusterStateResponse) && Objects.nonNull(clusterStateResponse.getState())) {
+            int limit = responseLimitSettings.getCatIndicesResponseLimit();
+            if (ResponseLimitSettings.isResponseLimitBreached(clusterStateResponse.getState().getMetadata(), INDICES, limit)) {
+                listener.onFailure(new ResponseLimitBreachedException("Too many indices requested.", limit, INDICES));
+            }
+        }
     }
 
     /**
@@ -287,7 +339,9 @@ private void sendIndicesStatsRequest(
     private GroupedActionListener<ActionResponse> createGroupedListener(
         final RestRequest request,
         final int size,
-        final ActionListener<Table> listener
+        final ActionListener<Table> listener,
+        final String[] indicesToBeQueried,
+        final PageToken pageToken
     ) {
         return new GroupedActionListener<>(new ActionListener<Collection<ActionResponse>>() {
             @Override
@@ -311,7 +365,15 @@ public void onResponse(final Collection<ActionResponse> responses) {
                     IndicesStatsResponse statsResponse = extractResponse(responses, IndicesStatsResponse.class);
                     Map<String, IndexStats> indicesStats = statsResponse.getIndices();
 
-                    Table responseTable = buildTable(request, indicesSettings, indicesHealths, indicesStats, indicesStates);
+                    Table responseTable = buildTable(
+                        request,
+                        indicesSettings,
+                        indicesHealths,
+                        indicesStats,
+                        indicesStates,
+                        getTableIterator(indicesToBeQueried, indicesSettings),
+                        pageToken
+                    );
                     listener.onResponse(responseTable);
                 } catch (Exception e) {
                     onFailure(e);
@@ -340,7 +402,11 @@ protected Set<String> responseParams() {
 
     @Override
     protected Table getTableWithHeader(final RestRequest request) {
-        Table table = new Table();
+        return getTableWithHeader(request, null);
+    }
+
+    protected Table getTableWithHeader(final RestRequest request, final PageToken pageToken) {
+        Table table = new Table(pageToken);
         table.startHeaders();
         table.addCell("health", "alias:h;desc:current health status");
         table.addCell("status", "alias:s;desc:open/close status");
@@ -704,22 +770,27 @@ protected Table getTableWithHeader(final RestRequest request) {
     }
 
     // package private for testing
-    Table buildTable(
+    protected Table buildTable(
         final RestRequest request,
         final Map<String, Settings> indicesSettings,
         final Map<String, ClusterIndexHealth> indicesHealths,
         final Map<String, IndexStats> indicesStats,
-        final Map<String, IndexMetadata> indicesMetadatas
+        final Map<String, IndexMetadata> indicesMetadatas,
+        final Iterator<Tuple<String, Settings>> tableIterator,
+        final PageToken pageToken
     ) {
-
         final String healthParam = request.param("health");
-        final Table table = getTableWithHeader(request);
+        final Table table = getTableWithHeader(request, pageToken);
+
+        while (tableIterator.hasNext()) {
+            final Tuple<String, Settings> tuple = tableIterator.next();
+            String indexName = tuple.v1();
+            Settings settings = tuple.v2();
 
-        indicesSettings.forEach((indexName, settings) -> {
             if (indicesMetadatas.containsKey(indexName) == false) {
                 // the index exists in the Get Indices response but is not present in the cluster state:
                 // it is likely that the index was deleted in the meanwhile, so we ignore it.
-                return;
+                continue;
             }
 
             final IndexMetadata indexMetadata = indicesMetadatas.get(indexName);
@@ -748,7 +819,7 @@ Table buildTable(
                     skip = ClusterHealthStatus.RED != healthStatusFilter;
                 }
                 if (skip) {
-                    return;
+                    continue;
                 }
             }
 
@@ -982,7 +1053,8 @@ Table buildTable(
             table.addCell(searchThrottled);
 
             table.endRow();
-        });
+
+        }
 
         return table;
     }
@@ -991,4 +1063,34 @@ Table buildTable(
     private static <A extends ActionResponse> A extractResponse(final Collection<? extends ActionResponse> responses, Class<A> c) {
         return (A) responses.stream().filter(c::isInstance).findFirst().get();
     }
+
+    @Override
+    public boolean isActionPaginated() {
+        return false;
+    }
+
+    protected IndexPaginationStrategy getPaginationStrategy(ClusterStateResponse clusterStateResponse) {
+        return null;
+    }
+
+    /**
+     * Provides the iterator to be used for building the response table.
+     */
+    protected Iterator<Tuple<String, Settings>> getTableIterator(String[] indices, Map<String, Settings> indexSettingsMap) {
+        return new Iterator<>() {
+            final Iterator<String> settingsMapIter = indexSettingsMap.keySet().iterator();
+
+            @Override
+            public boolean hasNext() {
+                return settingsMapIter.hasNext();
+            }
+
+            @Override
+            public Tuple<String, Settings> next() {
+                String index = settingsMapIter.next();
+                return new Tuple<>(index, indexSettingsMap.get(index));
+            }
+        };
+    }
+
 }
diff --git a/server/src/main/java/org/opensearch/rest/action/cat/RestSegmentsAction.java b/server/src/main/java/org/opensearch/rest/action/cat/RestSegmentsAction.java
index b88af4ac3eeed..69216cb46492d 100644
--- a/server/src/main/java/org/opensearch/rest/action/cat/RestSegmentsAction.java
+++ b/server/src/main/java/org/opensearch/rest/action/cat/RestSegmentsAction.java
@@ -42,6 +42,8 @@
 import org.opensearch.client.node.NodeClient;
 import org.opensearch.cluster.node.DiscoveryNodes;
 import org.opensearch.common.Table;
+import org.opensearch.common.breaker.ResponseLimitBreachedException;
+import org.opensearch.common.breaker.ResponseLimitSettings;
 import org.opensearch.common.logging.DeprecationLogger;
 import org.opensearch.core.common.Strings;
 import org.opensearch.index.engine.Segment;
@@ -52,9 +54,11 @@
 
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 
 import static java.util.Arrays.asList;
 import static java.util.Collections.unmodifiableList;
+import static org.opensearch.common.breaker.ResponseLimitSettings.LimitEntity.INDICES;
 import static org.opensearch.rest.RestRequest.Method.GET;
 
 /**
@@ -66,6 +70,12 @@ public class RestSegmentsAction extends AbstractCatAction {
 
     private static final DeprecationLogger deprecationLogger = DeprecationLogger.getLogger(RestSegmentsAction.class);
 
+    private final ResponseLimitSettings responseLimitSettings;
+
+    public RestSegmentsAction(ResponseLimitSettings responseLimitSettings) {
+        this.responseLimitSettings = responseLimitSettings;
+    }
+
     @Override
     public List<Route> routes() {
         return unmodifiableList(asList(new Route(GET, "/_cat/segments"), new Route(GET, "/_cat/segments/{index}")));
@@ -81,6 +91,11 @@ public boolean allowSystemIndexAccessByDefault() {
         return true;
     }
 
+    @Override
+    public boolean isRequestLimitCheckSupported() {
+        return true;
+    }
+
     @Override
     public RestChannelConsumer doCatRequest(final RestRequest request, final NodeClient client) {
         final String[] indices = Strings.splitStringByCommaToArray(request.param("index"));
@@ -96,6 +111,7 @@ public RestChannelConsumer doCatRequest(final RestRequest request, final NodeCli
         return channel -> client.admin().cluster().state(clusterStateRequest, new RestActionListener<ClusterStateResponse>(channel) {
             @Override
             public void processResponse(final ClusterStateResponse clusterStateResponse) {
+                validateRequestLimit(clusterStateResponse);
                 final IndicesSegmentsRequest indicesSegmentsRequest = new IndicesSegmentsRequest();
                 indicesSegmentsRequest.indices(indices);
                 client.admin().indices().segments(indicesSegmentsRequest, new RestResponseListener<IndicesSegmentResponse>(channel) {
@@ -110,6 +126,15 @@ public RestResponse buildResponse(final IndicesSegmentResponse indicesSegmentRes
         });
     }
 
+    private void validateRequestLimit(final ClusterStateResponse clusterStateResponse) {
+        if (isRequestLimitCheckSupported() && Objects.nonNull(clusterStateResponse) && Objects.nonNull(clusterStateResponse.getState())) {
+            int limit = responseLimitSettings.getCatSegmentsResponseLimit();
+            if (ResponseLimitSettings.isResponseLimitBreached(clusterStateResponse.getState().getRoutingTable(), INDICES, limit)) {
+                throw new ResponseLimitBreachedException("Segments from too many indices requested.", limit, INDICES);
+            }
+        }
+    }
+
     @Override
     protected void documentation(StringBuilder sb) {
         sb.append("/_cat/segments\n");
diff --git a/server/src/main/java/org/opensearch/rest/action/cat/RestShardsAction.java b/server/src/main/java/org/opensearch/rest/action/cat/RestShardsAction.java
index a7ad5fe6c14a3..c8b4e7472927e 100644
--- a/server/src/main/java/org/opensearch/rest/action/cat/RestShardsAction.java
+++ b/server/src/main/java/org/opensearch/rest/action/cat/RestShardsAction.java
@@ -105,6 +105,11 @@ protected void documentation(StringBuilder sb) {
         sb.append("/_cat/shards/{index}\n");
     }
 
+    @Override
+    public boolean isRequestLimitCheckSupported() {
+        return true;
+    }
+
     @Override
     public RestChannelConsumer doCatRequest(final RestRequest request, final NodeClient client) {
         final String[] indices = Strings.splitStringByCommaToArray(request.param("index"));
@@ -113,6 +118,7 @@ public RestChannelConsumer doCatRequest(final RestRequest request, final NodeCli
         shardsRequest.clusterManagerNodeTimeout(request.paramAsTime("cluster_manager_timeout", shardsRequest.clusterManagerNodeTimeout()));
         shardsRequest.setCancelAfterTimeInterval(request.paramAsTime("cancel_after_time_interval", NO_TIMEOUT));
         shardsRequest.setIndices(indices);
+        shardsRequest.setRequestLimitCheckSupported(isRequestLimitCheckSupported());
         parseDeprecatedMasterTimeoutParameter(shardsRequest, request, deprecationLogger, getName());
         return channel -> client.execute(CatShardsAction.INSTANCE, shardsRequest, new RestResponseListener<CatShardsResponse>(channel) {
             @Override
diff --git a/server/src/main/java/org/opensearch/rest/action/cat/RestTable.java b/server/src/main/java/org/opensearch/rest/action/cat/RestTable.java
index 4f1090b163ee6..d622dd7a956f4 100644
--- a/server/src/main/java/org/opensearch/rest/action/cat/RestTable.java
+++ b/server/src/main/java/org/opensearch/rest/action/cat/RestTable.java
@@ -58,8 +58,11 @@
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Set;
 
+import static org.opensearch.rest.pagination.PageToken.PAGINATED_RESPONSE_NEXT_TOKEN_KEY;
+
 /**
  * a REST table
  *
@@ -87,8 +90,37 @@ public static RestResponse buildXContentBuilder(Table table, RestChannel channel
         RestRequest request = channel.request();
         XContentBuilder builder = channel.newBuilder();
         List<DisplayHeader> displayHeaders = buildDisplayHeaders(table, request);
+        if (Objects.nonNull(table.getPageToken())) {
+            buildPaginatedXContentBuilder(table, request, builder, displayHeaders);
+        } else {
+            builder.startArray();
+            addRowsToXContentBuilder(table, request, builder, displayHeaders);
+            builder.endArray();
+        }
+        return new BytesRestResponse(RestStatus.OK, builder);
+    }
+
+    private static void buildPaginatedXContentBuilder(
+        Table table,
+        RestRequest request,
+        XContentBuilder builder,
+        List<DisplayHeader> displayHeaders
+    ) throws Exception {
+        assert Objects.nonNull(table.getPageToken().getPaginatedEntity()) : "Paginated element is required in-case of paginated responses";
+        builder.startObject();
+        builder.field(PAGINATED_RESPONSE_NEXT_TOKEN_KEY, table.getPageToken().getNextToken());
+        builder.startArray(table.getPageToken().getPaginatedEntity());
+        addRowsToXContentBuilder(table, request, builder, displayHeaders);
+        builder.endArray();
+        builder.endObject();
+    }
 
-        builder.startArray();
+    private static void addRowsToXContentBuilder(
+        Table table,
+        RestRequest request,
+        XContentBuilder builder,
+        List<DisplayHeader> displayHeaders
+    ) throws Exception {
         List<Integer> rowOrder = getRowOrder(table, request);
         for (Integer row : rowOrder) {
             builder.startObject();
@@ -97,8 +129,6 @@ public static RestResponse buildXContentBuilder(Table table, RestChannel channel
             }
             builder.endObject();
         }
-        builder.endArray();
-        return new BytesRestResponse(RestStatus.OK, builder);
     }
 
     public static RestResponse buildTextPlainResponse(Table table, RestChannel channel) throws IOException {
@@ -136,6 +166,11 @@ public static RestResponse buildTextPlainResponse(Table table, RestChannel chann
             }
             out.append("\n");
         }
+        // Adding a new row for next_token, in the response if the table is paginated.
+        if (Objects.nonNull(table.getPageToken())) {
+            out.append("next_token" + " " + table.getPageToken().getNextToken());
+            out.append("\n");
+        }
         out.close();
         return new BytesRestResponse(RestStatus.OK, BytesRestResponse.TEXT_CONTENT_TYPE, bytesOut.bytes());
     }
diff --git a/server/src/main/java/org/opensearch/rest/action/list/AbstractListAction.java b/server/src/main/java/org/opensearch/rest/action/list/AbstractListAction.java
new file mode 100644
index 0000000000000..f3d6d6653a550
--- /dev/null
+++ b/server/src/main/java/org/opensearch/rest/action/list/AbstractListAction.java
@@ -0,0 +1,77 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.rest.action.list;
+
+import org.opensearch.client.node.NodeClient;
+import org.opensearch.rest.RestRequest;
+import org.opensearch.rest.action.cat.AbstractCatAction;
+import org.opensearch.rest.pagination.PageParams;
+
+import java.io.IOException;
+import java.util.Objects;
+
+import static org.opensearch.rest.pagination.PageParams.PARAM_ASC_SORT_VALUE;
+import static org.opensearch.rest.pagination.PageParams.PARAM_DESC_SORT_VALUE;
+
+/**
+ * Base Transport action class for _list API.
+ * Serves as a base class for APIs wanting to support pagination.
+ * Existing _cat APIs can refer {@link org.opensearch.rest.action.cat.RestIndicesAction}.
+ * @opensearch.api
+ */
+public abstract class AbstractListAction extends AbstractCatAction {
+
+    private static final int DEFAULT_PAGE_SIZE = 100;
+    protected PageParams pageParams;
+
+    protected abstract void documentation(StringBuilder sb);
+
+    @Override
+    public RestChannelConsumer prepareRequest(final RestRequest request, final NodeClient client) throws IOException {
+        boolean helpWanted = request.paramAsBoolean("help", false);
+        if (helpWanted || isActionPaginated() == false) {
+            return super.prepareRequest(request, client);
+        }
+        this.pageParams = validateAndGetPageParams(request);
+        assert Objects.nonNull(pageParams) : "pageParams can not be null for paginated queries";
+        return doCatRequest(request, client);
+    }
+
+    @Override
+    public boolean isActionPaginated() {
+        return true;
+    }
+
+    /**
+     *
+     * @return Metadata that can be extracted out from the rest request. Query params supported by the action specific
+     * to pagination along with any respective validations to be added here.
+     */
+    protected PageParams validateAndGetPageParams(RestRequest restRequest) {
+        PageParams pageParams = restRequest.parsePaginatedQueryParams(defaultSort(), defaultPageSize());
+        // validating pageSize
+        if (pageParams.getSize() <= 0) {
+            throw new IllegalArgumentException("size must be greater than zero");
+        }
+        // Validating sort order
+        if (!(PARAM_ASC_SORT_VALUE.equals(pageParams.getSort()) || PARAM_DESC_SORT_VALUE.equals(pageParams.getSort()))) {
+            throw new IllegalArgumentException("value of sort can either be asc or desc");
+        }
+        return pageParams;
+    }
+
+    protected int defaultPageSize() {
+        return DEFAULT_PAGE_SIZE;
+    }
+
+    protected String defaultSort() {
+        return PARAM_ASC_SORT_VALUE;
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/rest/action/list/RestIndicesListAction.java b/server/src/main/java/org/opensearch/rest/action/list/RestIndicesListAction.java
new file mode 100644
index 0000000000000..971cab0535be9
--- /dev/null
+++ b/server/src/main/java/org/opensearch/rest/action/list/RestIndicesListAction.java
@@ -0,0 +1,114 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.rest.action.list;
+
+import org.opensearch.action.admin.cluster.state.ClusterStateResponse;
+import org.opensearch.common.breaker.ResponseLimitSettings;
+import org.opensearch.common.collect.Tuple;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.rest.RestRequest;
+import org.opensearch.rest.action.cat.RestIndicesAction;
+import org.opensearch.rest.pagination.IndexPaginationStrategy;
+import org.opensearch.rest.pagination.PageParams;
+
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+
+import static java.util.Arrays.asList;
+import static java.util.Collections.unmodifiableList;
+import static org.opensearch.rest.RestRequest.Method.GET;
+
+/**
+ * _list API action to output indices in pages.
+ *
+ * @opensearch.api
+ */
+public class RestIndicesListAction extends RestIndicesAction {
+
+    private static final int MAX_SUPPORTED_LIST_INDICES_PAGE_SIZE = 5000;
+    private static final int DEFAULT_LIST_INDICES_PAGE_SIZE = 500;
+
+    public RestIndicesListAction(final ResponseLimitSettings responseLimitSettings) {
+        super(responseLimitSettings);
+    }
+
+    @Override
+    public List<Route> routes() {
+        return unmodifiableList(asList(new Route(GET, "/_list/indices"), new Route(GET, "/_list/indices/{index}")));
+    }
+
+    @Override
+    public String getName() {
+        return "list_indices_action";
+    }
+
+    @Override
+    protected void documentation(StringBuilder sb) {
+        sb.append("/_list/indices\n");
+        sb.append("/_list/indices/{index}\n");
+    }
+
+    @Override
+    public boolean isActionPaginated() {
+        return true;
+    }
+
+    @Override
+    protected PageParams validateAndGetPageParams(RestRequest restRequest) {
+        PageParams pageParams = super.validateAndGetPageParams(restRequest);
+        // validate max supported pageSize
+        if (pageParams.getSize() > MAX_SUPPORTED_LIST_INDICES_PAGE_SIZE) {
+            throw new IllegalArgumentException("size should be less than [" + MAX_SUPPORTED_LIST_INDICES_PAGE_SIZE + "]");
+        }
+        // Next Token in the request will be validated by the IndexStrategyToken itself.
+        if (Objects.nonNull(pageParams.getRequestedToken())) {
+            IndexPaginationStrategy.IndexStrategyToken.validateIndexStrategyToken(pageParams.getRequestedToken());
+        }
+        return pageParams;
+    }
+
+    @Override
+    public boolean isRequestLimitCheckSupported() {
+        return false;
+    }
+
+    protected int defaultPageSize() {
+        return DEFAULT_LIST_INDICES_PAGE_SIZE;
+    }
+
+    @Override
+    protected IndexPaginationStrategy getPaginationStrategy(ClusterStateResponse clusterStateResponse) {
+        return new IndexPaginationStrategy(pageParams, clusterStateResponse.getState());
+    }
+
+    // Public for testing
+    @Override
+    public Iterator<Tuple<String, Settings>> getTableIterator(String[] indices, Map<String, Settings> indexSettingsMap) {
+        return new Iterator<>() {
+            int indexPos = 0;
+
+            @Override
+            public boolean hasNext() {
+                while (indexPos < indices.length && indexSettingsMap.containsKey(indices[indexPos]) == false) {
+                    indexPos++;
+                }
+                return indexPos < indices.length;
+            }
+
+            @Override
+            public Tuple<String, Settings> next() {
+                Tuple<String, Settings> tuple = new Tuple<>(indices[indexPos], indexSettingsMap.get(indices[indexPos]));
+                indexPos++;
+                return tuple;
+            }
+        };
+    }
+}
diff --git a/server/src/main/java/org/opensearch/rest/action/list/RestListAction.java b/server/src/main/java/org/opensearch/rest/action/list/RestListAction.java
new file mode 100644
index 0000000000000..4b8551ea7e14a
--- /dev/null
+++ b/server/src/main/java/org/opensearch/rest/action/list/RestListAction.java
@@ -0,0 +1,58 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.rest.action.list;
+
+import org.opensearch.client.node.NodeClient;
+import org.opensearch.core.rest.RestStatus;
+import org.opensearch.rest.BaseRestHandler;
+import org.opensearch.rest.BytesRestResponse;
+import org.opensearch.rest.RestRequest;
+
+import java.io.IOException;
+import java.util.List;
+
+import static java.util.Collections.singletonList;
+import static org.opensearch.rest.RestRequest.Method.GET;
+
+/**
+ * Base _list API endpoint
+ *
+ * @opensearch.api
+ */
+public class RestListAction extends BaseRestHandler {
+
+    private static final String LIST = ":‑|";
+    private static final String LIST_NL = LIST + "\n";
+    private final String HELP;
+
+    public RestListAction(List<AbstractListAction> listActions) {
+        StringBuilder sb = new StringBuilder();
+        sb.append(LIST_NL);
+        for (AbstractListAction listAction : listActions) {
+            listAction.documentation(sb);
+        }
+        HELP = sb.toString();
+    }
+
+    @Override
+    public List<Route> routes() {
+        return singletonList(new Route(GET, "/_list"));
+    }
+
+    @Override
+    public String getName() {
+        return "list_action";
+    }
+
+    @Override
+    public RestChannelConsumer prepareRequest(final RestRequest request, final NodeClient client) throws IOException {
+        return channel -> channel.sendResponse(new BytesRestResponse(RestStatus.OK, HELP));
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/rest/action/list/package-info.java b/server/src/main/java/org/opensearch/rest/action/list/package-info.java
new file mode 100644
index 0000000000000..8d6563ff9b344
--- /dev/null
+++ b/server/src/main/java/org/opensearch/rest/action/list/package-info.java
@@ -0,0 +1,12 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/**
+ * {@link org.opensearch.rest.RestHandler}s for actions that list out results in chunks of pages.
+ */
+package org.opensearch.rest.action.list;
diff --git a/server/src/main/java/org/opensearch/rest/pagination/IndexPaginationStrategy.java b/server/src/main/java/org/opensearch/rest/pagination/IndexPaginationStrategy.java
new file mode 100644
index 0000000000000..f89ab14e4b24d
--- /dev/null
+++ b/server/src/main/java/org/opensearch/rest/pagination/IndexPaginationStrategy.java
@@ -0,0 +1,185 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.rest.pagination;
+
+import org.opensearch.OpenSearchParseException;
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.common.Nullable;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Objects;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+
+import static org.opensearch.rest.pagination.PageParams.PARAM_ASC_SORT_VALUE;
+
+/**
+ * This strategy can be used by the Rest APIs wanting to paginate the responses based on Indices.
+ * The strategy considers create timestamps of indices as the keys to iterate over pages.
+ *
+ * @opensearch.internal
+ */
+public class IndexPaginationStrategy implements PaginationStrategy<String> {
+    private static final String DEFAULT_INDICES_PAGINATED_ENTITY = "indices";
+
+    private static final Comparator<IndexMetadata> ASC_COMPARATOR = (metadata1, metadata2) -> {
+        if (metadata1.getCreationDate() == metadata2.getCreationDate()) {
+            return metadata1.getIndex().getName().compareTo(metadata2.getIndex().getName());
+        }
+        return Long.compare(metadata1.getCreationDate(), metadata2.getCreationDate());
+    };
+    private static final Comparator<IndexMetadata> DESC_COMPARATOR = (metadata1, metadata2) -> {
+        if (metadata1.getCreationDate() == metadata2.getCreationDate()) {
+            return metadata2.getIndex().getName().compareTo(metadata1.getIndex().getName());
+        }
+        return Long.compare(metadata2.getCreationDate(), metadata1.getCreationDate());
+    };
+
+    private final PageToken pageToken;
+    private final List<String> requestedIndices;
+
+    public IndexPaginationStrategy(PageParams pageParams, ClusterState clusterState) {
+        // Get list of indices metadata sorted by their creation time and filtered by the last sent index
+        List<IndexMetadata> sortedIndices = PaginationStrategy.getSortedIndexMetadata(
+            clusterState,
+            getMetadataFilter(pageParams.getRequestedToken(), pageParams.getSort()),
+            PARAM_ASC_SORT_VALUE.equals(pageParams.getSort()) ? ASC_COMPARATOR : DESC_COMPARATOR
+        );
+        // Trim sortedIndicesList to get the list of indices metadata to be sent as response
+        List<IndexMetadata> metadataSublist = getMetadataSubList(sortedIndices, pageParams.getSize());
+        // Get list of index names from the trimmed metadataSublist
+        this.requestedIndices = metadataSublist.stream().map(metadata -> metadata.getIndex().getName()).collect(Collectors.toList());
+        this.pageToken = getResponseToken(
+            pageParams.getSize(),
+            sortedIndices.size(),
+            metadataSublist.isEmpty() ? null : metadataSublist.get(metadataSublist.size() - 1)
+        );
+    }
+
+    private static Predicate<IndexMetadata> getMetadataFilter(String requestedTokenStr, String sortOrder) {
+        boolean isAscendingSort = sortOrder.equals(PARAM_ASC_SORT_VALUE);
+        IndexStrategyToken requestedToken = Objects.isNull(requestedTokenStr) || requestedTokenStr.isEmpty()
+            ? null
+            : new IndexStrategyToken(requestedTokenStr);
+        if (Objects.isNull(requestedToken)) {
+            return indexMetadata -> true;
+        }
+        return metadata -> {
+            if (metadata.getIndex().getName().equals(requestedToken.lastIndexName)) {
+                return false;
+            } else if (metadata.getCreationDate() == requestedToken.lastIndexCreationTime) {
+                return isAscendingSort
+                    ? metadata.getIndex().getName().compareTo(requestedToken.lastIndexName) > 0
+                    : metadata.getIndex().getName().compareTo(requestedToken.lastIndexName) < 0;
+            }
+            return isAscendingSort
+                ? metadata.getCreationDate() > requestedToken.lastIndexCreationTime
+                : metadata.getCreationDate() < requestedToken.lastIndexCreationTime;
+        };
+    }
+
+    private List<IndexMetadata> getMetadataSubList(List<IndexMetadata> sortedIndices, final int pageSize) {
+        if (sortedIndices.isEmpty()) {
+            return new ArrayList<>();
+        }
+        return sortedIndices.subList(0, Math.min(pageSize, sortedIndices.size()));
+    }
+
+    private PageToken getResponseToken(final int pageSize, final int totalIndices, IndexMetadata lastIndex) {
+        if (totalIndices <= pageSize) {
+            return new PageToken(null, DEFAULT_INDICES_PAGINATED_ENTITY);
+        }
+        return new PageToken(
+            new IndexStrategyToken(lastIndex.getCreationDate(), lastIndex.getIndex().getName()).generateEncryptedToken(),
+            DEFAULT_INDICES_PAGINATED_ENTITY
+        );
+    }
+
+    @Override
+    @Nullable
+    public PageToken getResponseToken() {
+        return pageToken;
+    }
+
+    @Override
+    public List<String> getRequestedEntities() {
+        return Objects.isNull(requestedIndices) ? new ArrayList<>() : requestedIndices;
+    }
+
+    /**
+     * TokenParser to be used by {@link IndexPaginationStrategy}.
+     * Token would look like: CreationTimeOfLastRespondedIndex + | + NameOfLastRespondedIndex
+     */
+    public static class IndexStrategyToken {
+
+        private static final String JOIN_DELIMITER = "|";
+        private static final String SPLIT_REGEX = "\\|";
+        private static final int CREATE_TIME_POS_IN_TOKEN = 0;
+        private static final int INDEX_NAME_POS_IN_TOKEN = 1;
+
+        /**
+         * Represents creation times of last index which was displayed in the page.
+         * Used to identify the new start point in case the indices get created/deleted while queries are executed.
+         */
+        private final long lastIndexCreationTime;
+
+        /**
+         * Represents name of the last index which was displayed in the page.
+         * Used to identify whether the sorted list of indices has changed or not.
+         */
+        private final String lastIndexName;
+
+        public IndexStrategyToken(String requestedTokenString) {
+            // TODO: Avoid validating the requested token multiple times while calling from Rest and/or Transport layer.
+            validateIndexStrategyToken(requestedTokenString);
+            String decryptedToken = PaginationStrategy.decryptStringToken(requestedTokenString);
+            final String[] decryptedTokenElements = decryptedToken.split(SPLIT_REGEX);
+            this.lastIndexCreationTime = Long.parseLong(decryptedTokenElements[CREATE_TIME_POS_IN_TOKEN]);
+            this.lastIndexName = decryptedTokenElements[INDEX_NAME_POS_IN_TOKEN];
+        }
+
+        public IndexStrategyToken(long creationTimeOfLastRespondedIndex, String nameOfLastRespondedIndex) {
+            Objects.requireNonNull(nameOfLastRespondedIndex, "index name should be provided");
+            this.lastIndexCreationTime = creationTimeOfLastRespondedIndex;
+            this.lastIndexName = nameOfLastRespondedIndex;
+        }
+
+        public String generateEncryptedToken() {
+            return PaginationStrategy.encryptStringToken(String.join(JOIN_DELIMITER, String.valueOf(lastIndexCreationTime), lastIndexName));
+        }
+
+        /**
+         * Will perform simple validations on token received in the request.
+         * Token should be base64 encoded, and should contain the expected number of elements separated by "|".
+         * Timestamps should also be a valid long.
+         *
+         * @param requestedTokenStr string denoting the encoded token requested by the user.
+         */
+        public static void validateIndexStrategyToken(String requestedTokenStr) {
+            Objects.requireNonNull(requestedTokenStr, "requestedTokenString can not be null");
+            String decryptedToken = PaginationStrategy.decryptStringToken(requestedTokenStr);
+            final String[] decryptedTokenElements = decryptedToken.split(SPLIT_REGEX);
+            if (decryptedTokenElements.length != 2) {
+                throw new OpenSearchParseException(INCORRECT_TAINTED_NEXT_TOKEN_ERROR_MESSAGE);
+            }
+            try {
+                long creationTimeOfLastRespondedIndex = Long.parseLong(decryptedTokenElements[CREATE_TIME_POS_IN_TOKEN]);
+                if (creationTimeOfLastRespondedIndex <= 0) {
+                    throw new OpenSearchParseException(INCORRECT_TAINTED_NEXT_TOKEN_ERROR_MESSAGE);
+                }
+            } catch (NumberFormatException exception) {
+                throw new OpenSearchParseException(INCORRECT_TAINTED_NEXT_TOKEN_ERROR_MESSAGE);
+            }
+        }
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/rest/pagination/PageParams.java b/server/src/main/java/org/opensearch/rest/pagination/PageParams.java
new file mode 100644
index 0000000000000..9b2074bc3fed0
--- /dev/null
+++ b/server/src/main/java/org/opensearch/rest/pagination/PageParams.java
@@ -0,0 +1,48 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.rest.pagination;
+
+import org.opensearch.common.annotation.PublicApi;
+
+/**
+ *
+ * Class specific to paginated queries, which will contain common query params required by a paginated API.
+ */
+@PublicApi(since = "3.0.0")
+public class PageParams {
+
+    public static final String PARAM_SORT = "sort";
+    public static final String PARAM_NEXT_TOKEN = "next_token";
+    public static final String PARAM_SIZE = "size";
+    public static final String PARAM_ASC_SORT_VALUE = "asc";
+    public static final String PARAM_DESC_SORT_VALUE = "desc";
+
+    private final String requestedTokenStr;
+    private final String sort;
+    private final int size;
+
+    public PageParams(String requestedToken, String sort, int size) {
+        this.requestedTokenStr = requestedToken;
+        this.sort = sort;
+        this.size = size;
+    }
+
+    public String getSort() {
+        return sort;
+    }
+
+    public String getRequestedToken() {
+        return requestedTokenStr;
+    }
+
+    public int getSize() {
+        return size;
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/rest/pagination/PageToken.java b/server/src/main/java/org/opensearch/rest/pagination/PageToken.java
new file mode 100644
index 0000000000000..d62e1be695715
--- /dev/null
+++ b/server/src/main/java/org/opensearch/rest/pagination/PageToken.java
@@ -0,0 +1,42 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.rest.pagination;
+
+/**
+ * Pagination response metadata for a paginated query.
+ * @opensearch.internal
+ */
+public class PageToken {
+
+    public static final String PAGINATED_RESPONSE_NEXT_TOKEN_KEY = "next_token";
+
+    /**
+     * String denoting the next_token of paginated response, which will be used to fetch next page (if any).
+     */
+    private final String nextToken;
+
+    /**
+     * String denoting the element which is being paginated (for e.g. shards, indices..).
+     */
+    private final String paginatedEntity;
+
+    public PageToken(String nextToken, String paginatedElement) {
+        assert paginatedElement != null : "paginatedElement must be specified for a paginated response";
+        this.nextToken = nextToken;
+        this.paginatedEntity = paginatedElement;
+    }
+
+    public String getNextToken() {
+        return nextToken;
+    }
+
+    public String getPaginatedEntity() {
+        return paginatedEntity;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/rest/pagination/PaginationStrategy.java b/server/src/main/java/org/opensearch/rest/pagination/PaginationStrategy.java
new file mode 100644
index 0000000000000..7f9825a7cc09b
--- /dev/null
+++ b/server/src/main/java/org/opensearch/rest/pagination/PaginationStrategy.java
@@ -0,0 +1,75 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.rest.pagination;
+
+import org.opensearch.OpenSearchParseException;
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.metadata.IndexMetadata;
+
+import java.util.Base64;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Objects;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+
+import static java.nio.charset.StandardCharsets.UTF_8;
+
+/**
+ * Interface to be implemented by any strategy getting used for paginating rest responses.
+ *
+ * @opensearch.internal
+ */
+public interface PaginationStrategy<T> {
+
+    String INCORRECT_TAINTED_NEXT_TOKEN_ERROR_MESSAGE =
+        "Parameter [next_token] has been tainted and is incorrect. Please provide a valid [next_token].";
+
+    /**
+     *
+     * @return Base64 encoded string, which can be used to fetch next page of response.
+     */
+    PageToken getResponseToken();
+
+    /**
+     *
+     * @return List of elements fetched corresponding to the store and token received by the strategy.
+     */
+    List<T> getRequestedEntities();
+
+    /**
+     *
+     * Utility method to get list of indices filtered as per {@param filterPredicate} and the sorted according to {@param comparator}.
+     */
+    static List<IndexMetadata> getSortedIndexMetadata(
+        final ClusterState clusterState,
+        Predicate<IndexMetadata> filterPredicate,
+        Comparator<IndexMetadata> comparator
+    ) {
+        return clusterState.metadata().indices().values().stream().filter(filterPredicate).sorted(comparator).collect(Collectors.toList());
+    }
+
+    static String encryptStringToken(String tokenString) {
+        if (Objects.isNull(tokenString)) {
+            return null;
+        }
+        return Base64.getEncoder().encodeToString(tokenString.getBytes(UTF_8));
+    }
+
+    static String decryptStringToken(String encTokenString) {
+        if (Objects.isNull(encTokenString)) {
+            return null;
+        }
+        try {
+            return new String(Base64.getDecoder().decode(encTokenString), UTF_8);
+        } catch (IllegalArgumentException exception) {
+            throw new OpenSearchParseException(INCORRECT_TAINTED_NEXT_TOKEN_ERROR_MESSAGE);
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/rest/pagination/package-info.java b/server/src/main/java/org/opensearch/rest/pagination/package-info.java
new file mode 100644
index 0000000000000..324b8a6c46f88
--- /dev/null
+++ b/server/src/main/java/org/opensearch/rest/pagination/package-info.java
@@ -0,0 +1,12 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/**
+ * Exposes utilities for Rest actions to paginate responses.
+ */
+package org.opensearch.rest.pagination;
diff --git a/server/src/main/java/org/opensearch/snapshots/SnapshotsService.java b/server/src/main/java/org/opensearch/snapshots/SnapshotsService.java
index 22b2a72b36026..c80f18cdd82f7 100644
--- a/server/src/main/java/org/opensearch/snapshots/SnapshotsService.java
+++ b/server/src/main/java/org/opensearch/snapshots/SnapshotsService.java
@@ -38,6 +38,7 @@
 import org.opensearch.ExceptionsHelper;
 import org.opensearch.Version;
 import org.opensearch.action.ActionRunnable;
+import org.opensearch.action.LatchedActionListener;
 import org.opensearch.action.StepListener;
 import org.opensearch.action.admin.cluster.snapshots.clone.CloneSnapshotRequest;
 import org.opensearch.action.admin.cluster.snapshots.create.CreateSnapshotRequest;
@@ -621,6 +622,7 @@ public void onResponse(RepositoryData repositoryData) {
                                     return;
                                 }
                                 listener.onResponse(snapshotInfo);
+                                cleanOrphanTimestamp(repositoryName, repositoryData);
                             }
 
                             @Override
@@ -651,6 +653,57 @@ public TimeValue timeout() {
         }, "create_snapshot [" + snapshotName + ']', listener::onFailure);
     }
 
+    private void cleanOrphanTimestamp(String repoName, RepositoryData repositoryData) {
+        Collection<String> snapshotUUIDs = repositoryData.getSnapshotIds().stream().map(SnapshotId::getUUID).collect(Collectors.toSet());
+        Map<String, List<Long>> pinnedEntities = RemoteStorePinnedTimestampService.getPinnedEntities();
+
+        List<String> orphanPinnedEntities = pinnedEntities.keySet()
+            .stream()
+            .filter(pinnedEntity -> isOrphanPinnedEntity(repoName, snapshotUUIDs, pinnedEntity))
+            .collect(Collectors.toList());
+
+        if (orphanPinnedEntities.isEmpty()) {
+            return;
+        }
+
+        logger.info("Found {} orphan timestamps. Cleaning it up now", orphanPinnedEntities.size());
+        if (tryEnterRepoLoop(repoName)) {
+            deleteOrphanTimestamps(pinnedEntities, orphanPinnedEntities);
+            leaveRepoLoop(repoName);
+        } else {
+            logger.info("Concurrent snapshot create/delete is happening. Skipping clean up of orphan timestamps");
+        }
+    }
+
+    private boolean isOrphanPinnedEntity(String repoName, Collection<String> snapshotUUIDs, String pinnedEntity) {
+        Tuple<String, String> tokens = getRepoSnapshotUUIDTuple(pinnedEntity);
+        return Objects.equals(tokens.v1(), repoName) && snapshotUUIDs.contains(tokens.v2()) == false;
+    }
+
+    private void deleteOrphanTimestamps(Map<String, List<Long>> pinnedEntities, List<String> orphanPinnedEntities) {
+        final CountDownLatch latch = new CountDownLatch(orphanPinnedEntities.size());
+        for (String pinnedEntity : orphanPinnedEntities) {
+            assert pinnedEntities.get(pinnedEntity).size() == 1 : "Multiple timestamps for same repo-snapshot uuid found";
+            long orphanTimestamp = pinnedEntities.get(pinnedEntity).get(0);
+            remoteStorePinnedTimestampService.unpinTimestamp(
+                orphanTimestamp,
+                pinnedEntity,
+                new LatchedActionListener<>(new ActionListener<>() {
+                    @Override
+                    public void onResponse(Void unused) {}
+
+                    @Override
+                    public void onFailure(Exception e) {}
+                }, latch)
+            );
+        }
+        try {
+            latch.await();
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
     private void createSnapshotPreValidations(
         ClusterState currentState,
         RepositoryData repositoryData,
@@ -707,6 +760,11 @@ public static String getPinningEntity(String repositoryName, String snapshotUUID
         return repositoryName + SNAPSHOT_PINNED_TIMESTAMP_DELIMITER + snapshotUUID;
     }
 
+    public static Tuple<String, String> getRepoSnapshotUUIDTuple(String pinningEntity) {
+        String[] tokens = pinningEntity.split(SNAPSHOT_PINNED_TIMESTAMP_DELIMITER);
+        return new Tuple<>(tokens[0], tokens[1]);
+    }
+
     private void cloneSnapshotPinnedTimestamp(
         RepositoryData repositoryData,
         SnapshotId sourceSnapshot,
diff --git a/server/src/main/java/org/opensearch/threadpool/ThreadPool.java b/server/src/main/java/org/opensearch/threadpool/ThreadPool.java
index 81220ab171b34..d795fd252b7fc 100644
--- a/server/src/main/java/org/opensearch/threadpool/ThreadPool.java
+++ b/server/src/main/java/org/opensearch/threadpool/ThreadPool.java
@@ -53,6 +53,7 @@
 import org.opensearch.core.service.ReportingService;
 import org.opensearch.core.xcontent.ToXContentFragment;
 import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.gateway.remote.ClusterStateChecksum;
 import org.opensearch.node.Node;
 
 import java.io.IOException;
@@ -118,6 +119,7 @@ public static class Names {
         public static final String REMOTE_RECOVERY = "remote_recovery";
         public static final String REMOTE_STATE_READ = "remote_state_read";
         public static final String INDEX_SEARCHER = "index_searcher";
+        public static final String REMOTE_STATE_CHECKSUM = "remote_state_checksum";
     }
 
     /**
@@ -191,6 +193,7 @@ public static ThreadPoolType fromType(String type) {
         map.put(Names.REMOTE_RECOVERY, ThreadPoolType.SCALING);
         map.put(Names.REMOTE_STATE_READ, ThreadPoolType.SCALING);
         map.put(Names.INDEX_SEARCHER, ThreadPoolType.RESIZABLE);
+        map.put(Names.REMOTE_STATE_CHECKSUM, ThreadPoolType.FIXED);
         THREAD_POOL_TYPES = Collections.unmodifiableMap(map);
     }
 
@@ -307,6 +310,10 @@ public ThreadPool(
                 runnableTaskListener
             )
         );
+        builders.put(
+            Names.REMOTE_STATE_CHECKSUM,
+            new FixedExecutorBuilder(settings, Names.REMOTE_STATE_CHECKSUM, ClusterStateChecksum.COMPONENT_SIZE, 1000)
+        );
 
         for (final ExecutorBuilder<?> builder : customBuilders) {
             if (builders.containsKey(builder.name())) {
diff --git a/server/src/test/java/org/opensearch/ExceptionSerializationTests.java b/server/src/test/java/org/opensearch/ExceptionSerializationTests.java
index 2e4a2d7bdd59c..c1972daeab6d3 100644
--- a/server/src/test/java/org/opensearch/ExceptionSerializationTests.java
+++ b/server/src/test/java/org/opensearch/ExceptionSerializationTests.java
@@ -65,6 +65,7 @@
 import org.opensearch.cluster.routing.UnsupportedWeightedRoutingStateException;
 import org.opensearch.cluster.service.ClusterManagerThrottlingException;
 import org.opensearch.common.UUIDs;
+import org.opensearch.common.breaker.ResponseLimitBreachedException;
 import org.opensearch.common.collect.Tuple;
 import org.opensearch.common.io.PathUtils;
 import org.opensearch.common.io.stream.BytesStreamOutput;
@@ -898,6 +899,7 @@ public void testIds() {
         ids.put(172, ViewNotFoundException.class);
         ids.put(173, ViewAlreadyExistsException.class);
         ids.put(174, InvalidIndexContextException.class);
+        ids.put(175, ResponseLimitBreachedException.class);
         ids.put(10001, IndexCreateBlockException.class);
 
         Map<Class<? extends OpenSearchException>, Integer> reverse = new HashMap<>();
diff --git a/server/src/test/java/org/opensearch/action/RenamedTimeoutRequestParameterTests.java b/server/src/test/java/org/opensearch/action/RenamedTimeoutRequestParameterTests.java
index c7e1039686cc9..26c4670b4288c 100644
--- a/server/src/test/java/org/opensearch/action/RenamedTimeoutRequestParameterTests.java
+++ b/server/src/test/java/org/opensearch/action/RenamedTimeoutRequestParameterTests.java
@@ -11,7 +11,9 @@
 import org.opensearch.OpenSearchParseException;
 import org.opensearch.action.support.clustermanager.ClusterManagerNodeRequest;
 import org.opensearch.client.node.NodeClient;
+import org.opensearch.common.breaker.ResponseLimitSettings;
 import org.opensearch.common.logging.DeprecationLogger;
+import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.settings.SettingsFilter;
 import org.opensearch.core.common.bytes.BytesArray;
@@ -155,7 +157,10 @@ public void testCatAllocation() {
     }
 
     public void testCatIndices() {
-        RestIndicesAction action = new RestIndicesAction();
+        ClusterSettings clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        Settings settings = Settings.builder().build();
+        ResponseLimitSettings responseLimitSettings = new ResponseLimitSettings(clusterSettings, settings);
+        RestIndicesAction action = new RestIndicesAction(responseLimitSettings);
         Exception e = assertThrows(OpenSearchParseException.class, () -> action.doCatRequest(getRestRequestWithBothParams(), client));
         assertThat(e.getMessage(), containsString(DUPLICATE_PARAMETER_ERROR_MESSAGE));
         assertWarnings(MASTER_TIMEOUT_DEPRECATED_MESSAGE);
@@ -239,7 +244,10 @@ public void testCatThreadPool() {
     }
 
     public void testCatSegments() {
-        RestSegmentsAction action = new RestSegmentsAction();
+        final ClusterSettings clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        final Settings settings = Settings.builder().build();
+        final ResponseLimitSettings responseLimitSettings = new ResponseLimitSettings(clusterSettings, settings);
+        RestSegmentsAction action = new RestSegmentsAction(responseLimitSettings);
         Exception e = assertThrows(OpenSearchParseException.class, () -> action.doCatRequest(getRestRequestWithBothParams(), client));
         assertThat(e.getMessage(), containsString(DUPLICATE_PARAMETER_ERROR_MESSAGE));
         assertWarnings(MASTER_TIMEOUT_DEPRECATED_MESSAGE);
diff --git a/server/src/test/java/org/opensearch/action/admin/cluster/node/stats/NodeStatsTests.java b/server/src/test/java/org/opensearch/action/admin/cluster/node/stats/NodeStatsTests.java
index 11902728eed07..34065daff2b8a 100644
--- a/server/src/test/java/org/opensearch/action/admin/cluster/node/stats/NodeStatsTests.java
+++ b/server/src/test/java/org/opensearch/action/admin/cluster/node/stats/NodeStatsTests.java
@@ -95,6 +95,7 @@
 import org.opensearch.node.NodeResourceUsageStats;
 import org.opensearch.node.NodesResourceUsageStats;
 import org.opensearch.node.ResponseCollectorService;
+import org.opensearch.node.remotestore.RemoteStoreNodeStats;
 import org.opensearch.ratelimitting.admissioncontrol.controllers.AdmissionController;
 import org.opensearch.ratelimitting.admissioncontrol.controllers.CpuBasedAdmissionController;
 import org.opensearch.ratelimitting.admissioncontrol.enums.AdmissionControlActionType;
@@ -614,6 +615,14 @@ public void testSerialization() throws IOException {
                 } else {
                     assertEquals(nodeCacheStats, deserializedNodeCacheStats);
                 }
+
+                RemoteStoreNodeStats remoteStoreNodeStats = nodeStats.getRemoteStoreNodeStats();
+                RemoteStoreNodeStats deserializedRemoteStoreNodeStats = deserializedNodeStats.getRemoteStoreNodeStats();
+                if (remoteStoreNodeStats == null) {
+                    assertNull(deserializedRemoteStoreNodeStats);
+                } else {
+                    assertEquals(remoteStoreNodeStats, deserializedRemoteStoreNodeStats);
+                }
             }
         }
     }
@@ -996,6 +1005,16 @@ public void apply(String action, AdmissionControlActionType admissionControlActi
             nodeCacheStats = new NodeCacheStats(cacheStatsMap, flags);
         }
 
+        RemoteStoreNodeStats remoteStoreNodeStats = null;
+        if (frequently()) {
+            remoteStoreNodeStats = new RemoteStoreNodeStats() {
+                @Override
+                public long getLastSuccessfulFetchOfPinnedTimestamps() {
+                    return 123456L;
+                }
+            };
+        }
+
         // TODO: Only remote_store based aspects of NodeIndicesStats are being tested here.
         // It is possible to test other metrics in NodeIndicesStats as well since it extends Writeable now
         return new NodeStats(
@@ -1027,7 +1046,8 @@ public void apply(String action, AdmissionControlActionType admissionControlActi
             segmentReplicationRejectionStats,
             null,
             admissionControlStats,
-            nodeCacheStats
+            nodeCacheStats,
+            remoteStoreNodeStats
         );
     }
 
diff --git a/server/src/test/java/org/opensearch/action/admin/cluster/stats/ClusterStatsNodesTests.java b/server/src/test/java/org/opensearch/action/admin/cluster/stats/ClusterStatsNodesTests.java
index 1c4a77905d73f..823661ba14abf 100644
--- a/server/src/test/java/org/opensearch/action/admin/cluster/stats/ClusterStatsNodesTests.java
+++ b/server/src/test/java/org/opensearch/action/admin/cluster/stats/ClusterStatsNodesTests.java
@@ -349,6 +349,7 @@ private ClusterStatsNodeResponse createClusterStatsNodeResponse(
             null,
             null,
             null,
+            null,
             null
         );
         if (defaultBehavior) {
diff --git a/server/src/test/java/org/opensearch/cluster/DiskUsageTests.java b/server/src/test/java/org/opensearch/cluster/DiskUsageTests.java
index 5539dd26dd52d..cd050fb346563 100644
--- a/server/src/test/java/org/opensearch/cluster/DiskUsageTests.java
+++ b/server/src/test/java/org/opensearch/cluster/DiskUsageTests.java
@@ -195,6 +195,7 @@ public void testFillDiskUsage() {
                 null,
                 null,
                 null,
+                null,
                 null
             ),
             new NodeStats(
@@ -226,6 +227,7 @@ public void testFillDiskUsage() {
                 null,
                 null,
                 null,
+                null,
                 null
             ),
             new NodeStats(
@@ -257,6 +259,7 @@ public void testFillDiskUsage() {
                 null,
                 null,
                 null,
+                null,
                 null
             )
         );
@@ -319,6 +322,7 @@ public void testFillDiskUsageSomeInvalidValues() {
                 null,
                 null,
                 null,
+                null,
                 null
             ),
             new NodeStats(
@@ -350,6 +354,7 @@ public void testFillDiskUsageSomeInvalidValues() {
                 null,
                 null,
                 null,
+                null,
                 null
             ),
             new NodeStats(
@@ -381,6 +386,7 @@ public void testFillDiskUsageSomeInvalidValues() {
                 null,
                 null,
                 null,
+                null,
                 null
             )
         );
diff --git a/server/src/test/java/org/opensearch/common/breaker/ResponseLimitSettingsTests.java b/server/src/test/java/org/opensearch/common/breaker/ResponseLimitSettingsTests.java
new file mode 100644
index 0000000000000..4633d055b3505
--- /dev/null
+++ b/server/src/test/java/org/opensearch/common/breaker/ResponseLimitSettingsTests.java
@@ -0,0 +1,228 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.common.breaker;
+
+import org.opensearch.Version;
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.cluster.metadata.Metadata;
+import org.opensearch.cluster.routing.IndexRoutingTable;
+import org.opensearch.cluster.routing.IndexShardRoutingTable;
+import org.opensearch.cluster.routing.RoutingTable;
+import org.opensearch.cluster.routing.ShardRouting;
+import org.opensearch.cluster.routing.ShardRoutingState;
+import org.opensearch.cluster.routing.TestShardRouting;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.core.index.Index;
+import org.opensearch.core.index.shard.ShardId;
+import org.opensearch.test.OpenSearchTestCase;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.opensearch.common.breaker.ResponseLimitSettings.CAT_INDICES_RESPONSE_LIMIT_SETTING;
+import static org.opensearch.common.breaker.ResponseLimitSettings.CAT_SEGMENTS_RESPONSE_LIMIT_SETTING;
+import static org.opensearch.common.breaker.ResponseLimitSettings.CAT_SHARDS_RESPONSE_LIMIT_SETTING;
+
+public class ResponseLimitSettingsTests extends OpenSearchTestCase {
+
+    public void testIsResponseLimitBreachedForNullMetadataExpectNotBreached() {
+        final Settings settings = Settings.builder().build();
+        final ClusterSettings clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        final ResponseLimitSettings responseLimitSettings = new ResponseLimitSettings(clusterSettings, settings);
+        final boolean breached = ResponseLimitSettings.isResponseLimitBreached(
+            (Metadata) null,
+            ResponseLimitSettings.LimitEntity.INDICES,
+            0
+        );
+        assertFalse(breached);
+    }
+
+    public void testIsResponseLimitBreachedForNullRoutingTableExpectNotBreached() {
+        final Settings settings = Settings.builder().build();
+        final ClusterSettings clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        final ResponseLimitSettings responseLimitSettings = new ResponseLimitSettings(clusterSettings, settings);
+        final boolean breached = ResponseLimitSettings.isResponseLimitBreached(
+            (RoutingTable) null,
+            ResponseLimitSettings.LimitEntity.INDICES,
+            0
+        );
+        assertFalse(breached);
+    }
+
+    public void testIsResponseLimitBreachedForNullLimitEntityWithRoutingTableExpectException() {
+        final ClusterState clusterState = buildClusterState("test-index-1", "test-index-2", "test-index-3");
+        expectThrows(
+            IllegalArgumentException.class,
+            () -> ResponseLimitSettings.isResponseLimitBreached(clusterState.getRoutingTable(), null, 4)
+        );
+    }
+
+    public void testIsResponseLimitBreachedForNullLimitEntityWithMetadataExpectException() {
+        final ClusterState clusterState = buildClusterState("test-index-1", "test-index-2", "test-index-3");
+        expectThrows(
+            IllegalArgumentException.class,
+            () -> ResponseLimitSettings.isResponseLimitBreached(clusterState.getMetadata(), null, 4)
+        );
+    }
+
+    public void testIsResponseLimitBreachedForCatIndicesWithNoSettingPassedExpectNotBreached() {
+        // Don't set setting
+        final Settings settings = Settings.builder().build();
+        final boolean breached = isBreachedForIndices(settings);
+        assertFalse(breached);
+    }
+
+    public void testIsResponseLimitBreachedForCatIndicesWithSettingDisabledExpectNotBreached() {
+        // Don't enable limit
+        final Settings settings = Settings.builder().put(CAT_INDICES_RESPONSE_LIMIT_SETTING.getKey(), -1).build();
+        final boolean breached = isBreachedForIndices(settings);
+        assertFalse(breached);
+    }
+
+    public void testIsResponseLimitBreachedForCatIndicesWithSettingEnabledExpectBreached() {
+        // Set limit of 1 index
+        final Settings settings = Settings.builder().put(CAT_INDICES_RESPONSE_LIMIT_SETTING.getKey(), 1).build();
+        final boolean breached = isBreachedForIndices(settings);
+        assertTrue(breached);
+    }
+
+    public void testIsResponseLimitBreachedForCatIndicesWithSettingEnabledExpectNotBreached() {
+        // Set limit of 5 indices
+        final Settings settings = Settings.builder().put(CAT_INDICES_RESPONSE_LIMIT_SETTING.getKey(), 5).build();
+        final boolean breached = isBreachedForIndices(settings);
+        assertFalse(breached);
+    }
+
+    private static boolean isBreachedForIndices(final Settings settings) {
+        final ClusterSettings clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        final ResponseLimitSettings responseLimitSettings = new ResponseLimitSettings(clusterSettings, settings);
+        // Pass cluster state with 3 indices
+        final ClusterState clusterState = buildClusterState("test-index-1", "test-index-2", "test-index-3");
+        return ResponseLimitSettings.isResponseLimitBreached(
+            clusterState.getMetadata(),
+            ResponseLimitSettings.LimitEntity.INDICES,
+            responseLimitSettings.getCatIndicesResponseLimit()
+        );
+    }
+
+    public void testIsResponseLimitBreachedForCatShardsWithSettingDisabledExpectNotBreached() {
+        // Don't enable limit
+        final Settings settings = Settings.builder().put(CAT_SHARDS_RESPONSE_LIMIT_SETTING.getKey(), -1).build();
+        final boolean breached = isBreachedForShards(settings);
+        assertFalse(breached);
+    }
+
+    public void testIsResponseLimitBreachedForCatShardsWithNoSettingPassedExpectNotBreached() {
+        // Don't set setting
+        final Settings settings = Settings.builder().build();
+        final boolean breached = isBreachedForShards(settings);
+        assertFalse(breached);
+    }
+
+    private static boolean isBreachedForShards(Settings settings) {
+        final ClusterSettings clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        final ResponseLimitSettings responseLimitSettings = new ResponseLimitSettings(clusterSettings, settings);
+        // Build cluster state with 3 shards
+        final ClusterState clusterState = buildClusterState("test-index-1", "test-index-2", "test-index-3");
+        return ResponseLimitSettings.isResponseLimitBreached(
+            clusterState.getRoutingTable(),
+            ResponseLimitSettings.LimitEntity.SHARDS,
+            responseLimitSettings.getCatShardsResponseLimit()
+        );
+    }
+
+    public void testIsResponseLimitBreachedForCatShardsWithSettingEnabledExpectBreached() {
+        // Set limit of 2 shards
+        final Settings settings = Settings.builder().put(CAT_SHARDS_RESPONSE_LIMIT_SETTING.getKey(), 2).build();
+        final boolean breached = isBreachedForShards(settings);
+        assertTrue(breached);
+    }
+
+    public void testIsResponseLimitBreachedForCatShardsWithSettingEnabledExpectNotBreached() {
+        // Set limit of 9 shards
+        final Settings settings = Settings.builder().put(CAT_SHARDS_RESPONSE_LIMIT_SETTING.getKey(), 9).build();
+        final boolean breached = isBreachedForShards(settings);
+        assertFalse(breached);
+    }
+
+    public void testIsResponseLimitBreachedForCatSegmentsWithSettingDisabledExpectNotBreached() {
+        // Don't enable limit
+        final Settings settings = Settings.builder().put(CAT_SEGMENTS_RESPONSE_LIMIT_SETTING.getKey(), -1).build();
+        final boolean breached = isBreachedForSegments(settings);
+        assertFalse(breached);
+    }
+
+    public void testIsResponseLimitBreachedForCatSegmentsWithNoSettingPassedExpectNotBreached() {
+        // Don't set setting
+        final Settings settings = Settings.builder().build();
+        final boolean breached = isBreachedForSegments(settings);
+        assertFalse(breached);
+    }
+
+    private static boolean isBreachedForSegments(Settings settings) {
+        final ClusterSettings clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        final ResponseLimitSettings responseLimitSettings = new ResponseLimitSettings(clusterSettings, settings);
+        // Build cluster state with 3 indices
+        final ClusterState clusterState = buildClusterState("test-index-1", "test-index-2", "test-index-3");
+        final boolean breached = ResponseLimitSettings.isResponseLimitBreached(
+            clusterState.getRoutingTable(),
+            ResponseLimitSettings.LimitEntity.INDICES,
+            responseLimitSettings.getCatSegmentsResponseLimit()
+        );
+        return breached;
+    }
+
+    public void testIsResponseLimitBreachedForCatSegmentsWithSettingEnabledExpectBreached() {
+        // Set limit of 1 index
+        final Settings settings = Settings.builder().put(CAT_SEGMENTS_RESPONSE_LIMIT_SETTING.getKey(), 1).build();
+        final boolean breached = isBreachedForSegments(settings);
+        assertTrue(breached);
+    }
+
+    public void testIsResponseLimitBreachedForCatSegmentsWithSettingEnabledExpectNotBreached() {
+        // Set limit of 5 indices
+        final Settings settings = Settings.builder().put(CAT_SEGMENTS_RESPONSE_LIMIT_SETTING.getKey(), 5).build();
+        final boolean breached = isBreachedForSegments(settings);
+        assertFalse(breached);
+    }
+
+    private static ClusterState buildClusterState(String... indices) {
+        final Metadata.Builder metadata = Metadata.builder();
+        for (String index : indices) {
+            metadata.put(IndexMetadata.builder(index).settings(settings(Version.CURRENT)).numberOfShards(1).numberOfReplicas(0));
+        }
+        final Map<String, IndexRoutingTable> indexRoutingTableMap = new HashMap<>();
+        for (String s : indices) {
+            final Index index = new Index(s, "uuid");
+            final ShardId primaryShardId = new ShardId(index, 0);
+            final ShardRouting primaryShardRouting = createShardRouting(primaryShardId, true);
+            final ShardId replicaShardId = new ShardId(index, 1);
+            final ShardRouting replicaShardRouting = createShardRouting(replicaShardId, false);
+            final IndexShardRoutingTable.Builder indexShardRoutingTableBuilder = new IndexShardRoutingTable.Builder(primaryShardId);
+            indexShardRoutingTableBuilder.addShard(primaryShardRouting);
+            indexShardRoutingTableBuilder.addShard(replicaShardRouting);
+            final IndexRoutingTable.Builder indexRoutingTable = IndexRoutingTable.builder(index)
+                .addShard(primaryShardRouting)
+                .addShard(replicaShardRouting)
+                .addIndexShard(indexShardRoutingTableBuilder.build());
+            indexRoutingTableMap.put(index.getName(), indexRoutingTable.build());
+        }
+        final RoutingTable routingTable = new RoutingTable(1, indexRoutingTableMap);
+        return ClusterState.builder(org.opensearch.cluster.ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
+            .metadata(metadata)
+            .routingTable(routingTable)
+            .build();
+    }
+
+    private static ShardRouting createShardRouting(ShardId shardId, boolean isPrimary) {
+        return TestShardRouting.newShardRouting(shardId, randomAlphaOfLength(4), isPrimary, ShardRoutingState.STARTED);
+    }
+}
diff --git a/server/src/test/java/org/opensearch/common/util/FeatureFlagTests.java b/server/src/test/java/org/opensearch/common/util/FeatureFlagTests.java
index 6b6c7b96266d3..6d9d1aad3c5d5 100644
--- a/server/src/test/java/org/opensearch/common/util/FeatureFlagTests.java
+++ b/server/src/test/java/org/opensearch/common/util/FeatureFlagTests.java
@@ -14,7 +14,6 @@
 
 import static org.opensearch.common.util.FeatureFlags.DATETIME_FORMATTER_CACHING;
 import static org.opensearch.common.util.FeatureFlags.EXTENSIONS;
-import static org.opensearch.common.util.FeatureFlags.IDENTITY;
 
 public class FeatureFlagTests extends OpenSearchTestCase {
 
@@ -40,7 +39,7 @@ public void testNonBooleanFeatureFlag() {
     }
 
     public void testBooleanFeatureFlagWithDefaultSetToFalse() {
-        final String testFlag = IDENTITY;
+        final String testFlag = EXTENSIONS;
         FeatureFlags.initializeFeatureFlags(Settings.EMPTY);
         assertNotNull(testFlag);
         assertFalse(FeatureFlags.isEnabled(testFlag));
@@ -49,15 +48,13 @@ public void testBooleanFeatureFlagWithDefaultSetToFalse() {
     public void testBooleanFeatureFlagInitializedWithEmptySettingsAndDefaultSetToFalse() {
         final String testFlag = DATETIME_FORMATTER_CACHING;
         FeatureFlags.initializeFeatureFlags(Settings.EMPTY);
-        assertNotNull(testFlag);
         assertFalse(FeatureFlags.isEnabled(testFlag));
     }
 
     public void testInitializeFeatureFlagsWithExperimentalSettings() {
-        FeatureFlags.initializeFeatureFlags(Settings.builder().put(IDENTITY, true).build());
-        assertTrue(FeatureFlags.isEnabled(IDENTITY));
+        FeatureFlags.initializeFeatureFlags(Settings.builder().put(EXTENSIONS, true).build());
+        assertTrue(FeatureFlags.isEnabled(EXTENSIONS));
         assertFalse(FeatureFlags.isEnabled(DATETIME_FORMATTER_CACHING));
-        assertFalse(FeatureFlags.isEnabled(EXTENSIONS));
         // reset FeatureFlags to defaults
         FeatureFlags.initializeFeatureFlags(Settings.EMPTY);
     }
diff --git a/server/src/test/java/org/opensearch/gateway/AsyncShardFetchTests.java b/server/src/test/java/org/opensearch/gateway/AsyncShardFetchTests.java
index db97c3ece94ba..c25150873a1ce 100644
--- a/server/src/test/java/org/opensearch/gateway/AsyncShardFetchTests.java
+++ b/server/src/test/java/org/opensearch/gateway/AsyncShardFetchTests.java
@@ -35,10 +35,13 @@
 import org.opensearch.Version;
 import org.opensearch.action.FailedNodeException;
 import org.opensearch.action.support.nodes.BaseNodeResponse;
+import org.opensearch.cluster.ClusterManagerMetrics;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNodeRole;
 import org.opensearch.cluster.node.DiscoveryNodes;
 import org.opensearch.core.index.shard.ShardId;
+import org.opensearch.telemetry.metrics.Counter;
+import org.opensearch.telemetry.metrics.MetricsRegistry;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.threadpool.TestThreadPool;
 import org.opensearch.threadpool.ThreadPool;
@@ -54,6 +57,12 @@
 import static java.util.Collections.emptyMap;
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.sameInstance;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.anyDouble;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
 
 public class AsyncShardFetchTests extends OpenSearchTestCase {
     private final DiscoveryNode node1 = new DiscoveryNode(
@@ -78,13 +87,29 @@ public class AsyncShardFetchTests extends OpenSearchTestCase {
 
     private ThreadPool threadPool;
     private TestFetch test;
+    private Counter asyncFetchSuccessCounter;
+    private Counter asyncFetchFailureCounter;
+    private Counter dummyCounter;
 
     @Override
     @Before
     public void setUp() throws Exception {
         super.setUp();
         this.threadPool = new TestThreadPool(getTestName());
-        this.test = new TestFetch(threadPool);
+        final MetricsRegistry metricsRegistry = mock(MetricsRegistry.class);
+        this.asyncFetchFailureCounter = mock(Counter.class);
+        this.asyncFetchSuccessCounter = mock(Counter.class);
+        this.dummyCounter = mock(Counter.class);
+        when(metricsRegistry.createCounter(anyString(), anyString(), anyString())).thenAnswer(invocationOnMock -> {
+            String counterName = (String) invocationOnMock.getArguments()[0];
+            if (counterName.contains("async.fetch.success.count")) {
+                return asyncFetchSuccessCounter;
+            } else if (counterName.contains("async.fetch.failure.count")) {
+                return asyncFetchFailureCounter;
+            }
+            return dummyCounter;
+        });
+        this.test = new TestFetch(threadPool, metricsRegistry);
     }
 
     @After
@@ -100,14 +125,26 @@ public void testClose() throws Exception {
         AsyncShardFetch.FetchResult<Response> fetchData = test.fetchData(nodes, emptyMap());
         assertThat(fetchData.hasData(), equalTo(false));
         assertThat(test.reroute.get(), equalTo(0));
+        // counter remains 0 because fetch is ongoing
+        verify(asyncFetchSuccessCounter, times(0)).add(anyDouble());
+        verify(asyncFetchFailureCounter, times(0)).add(anyDouble());
 
         // fire a response, wait on reroute incrementing
         test.fireSimulationAndWait(node1.getId());
+        // counter goes up because fetch completed
+        verify(asyncFetchSuccessCounter, times(1)).add(1.0);
+        verify(asyncFetchSuccessCounter, times(1)).add(anyDouble());
+        verify(asyncFetchFailureCounter, times(0)).add(anyDouble());
+
         // verify we get back the data node
         assertThat(test.reroute.get(), equalTo(1));
         test.close();
         try {
             test.fetchData(nodes, emptyMap());
+            // counter should not go up when calling fetchData since fetch never completed
+            verify(asyncFetchSuccessCounter, times(1)).add(1.0);
+            verify(asyncFetchSuccessCounter, times(1)).add(anyDouble());
+            verify(asyncFetchFailureCounter, times(0)).add(anyDouble());
             fail("fetch data should fail when closed");
         } catch (IllegalStateException e) {
             // all is well
@@ -125,12 +162,21 @@ public void testFullCircleSingleNodeSuccess() throws Exception {
 
         // fire a response, wait on reroute incrementing
         test.fireSimulationAndWait(node1.getId());
+        // total counter goes up by 1 after success
+        verify(asyncFetchSuccessCounter, times(1)).add(1.0);
+        verify(asyncFetchSuccessCounter, times(1)).add(anyDouble());
+        verify(asyncFetchFailureCounter, times(0)).add(anyDouble());
+
         // verify we get back the data node
         assertThat(test.reroute.get(), equalTo(1));
         fetchData = test.fetchData(nodes, emptyMap());
         assertThat(fetchData.hasData(), equalTo(true));
         assertThat(fetchData.getData().size(), equalTo(1));
         assertThat(fetchData.getData().get(node1), sameInstance(response1));
+        // counter remains same because fetchData does not trigger new async fetch
+        verify(asyncFetchSuccessCounter, times(1)).add(1.0);
+        verify(asyncFetchSuccessCounter, times(1)).add(anyDouble());
+        verify(asyncFetchFailureCounter, times(0)).add(anyDouble());
     }
 
     public void testFullCircleSingleNodeFailure() throws Exception {
@@ -145,24 +191,47 @@ public void testFullCircleSingleNodeFailure() throws Exception {
 
         // fire a response, wait on reroute incrementing
         test.fireSimulationAndWait(node1.getId());
+        verify(asyncFetchSuccessCounter, times(0)).add(anyDouble());
+        verify(asyncFetchFailureCounter, times(1)).add(1.0);
+        verify(asyncFetchFailureCounter, times(1)).add(anyDouble());
+
         // failure, fetched data exists, but has no data
         assertThat(test.reroute.get(), equalTo(1));
         fetchData = test.fetchData(nodes, emptyMap());
         assertThat(fetchData.hasData(), equalTo(true));
         assertThat(fetchData.getData().size(), equalTo(0));
+        // counter remains same because fetchData does not trigger new async fetch
+        verify(asyncFetchSuccessCounter, times(0)).add(anyDouble());
+        verify(asyncFetchFailureCounter, times(1)).add(1.0);
+        verify(asyncFetchFailureCounter, times(1)).add(anyDouble());
 
         // on failure, we reset the failure on a successive call to fetchData, and try again afterwards
         test.addSimulation(node1.getId(), response1);
         fetchData = test.fetchData(nodes, emptyMap());
         assertThat(fetchData.hasData(), equalTo(false));
+        // No additional failure, empty data so no change in counter
+        verify(asyncFetchSuccessCounter, times(0)).add(anyDouble());
+        verify(asyncFetchFailureCounter, times(1)).add(1.0);
+        verify(asyncFetchFailureCounter, times(1)).add(anyDouble());
 
         test.fireSimulationAndWait(node1.getId());
+        // Success counter will increase
+        verify(asyncFetchSuccessCounter, times(1)).add(1.0);
+        verify(asyncFetchSuccessCounter, times(1)).add(anyDouble());
+        verify(asyncFetchFailureCounter, times(1)).add(1.0);
+        verify(asyncFetchFailureCounter, times(1)).add(anyDouble());
+
         // 2 reroutes, cause we have a failure that we clear
         assertThat(test.reroute.get(), equalTo(3));
         fetchData = test.fetchData(nodes, emptyMap());
         assertThat(fetchData.hasData(), equalTo(true));
         assertThat(fetchData.getData().size(), equalTo(1));
         assertThat(fetchData.getData().get(node1), sameInstance(response1));
+        // counter remains same because fetchData does not trigger new async fetch
+        verify(asyncFetchSuccessCounter, times(1)).add(1.0);
+        verify(asyncFetchSuccessCounter, times(1)).add(anyDouble());
+        verify(asyncFetchFailureCounter, times(1)).add(1.0);
+        verify(asyncFetchFailureCounter, times(1)).add(anyDouble());
     }
 
     public void testIgnoreResponseFromDifferentRound() throws Exception {
@@ -173,20 +242,40 @@ public void testIgnoreResponseFromDifferentRound() throws Exception {
         AsyncShardFetch.FetchResult<Response> fetchData = test.fetchData(nodes, emptyMap());
         assertThat(fetchData.hasData(), equalTo(false));
         assertThat(test.reroute.get(), equalTo(0));
+        // counter 0 because fetchData is not completed
+        verify(asyncFetchSuccessCounter, times(0)).add(anyDouble());
+        verify(asyncFetchFailureCounter, times(0)).add(anyDouble());
 
         // handle a response with incorrect round id, wait on reroute incrementing
         test.processAsyncFetch(Collections.singletonList(response1), Collections.emptyList(), 0);
         assertThat(fetchData.hasData(), equalTo(false));
         assertThat(test.reroute.get(), equalTo(1));
+        // success counter increments to 1 because we called processAsyncFetch with a valid response, even though the round was incorrect
+        // failure counter also increments by 1 with empty list
+        verify(asyncFetchSuccessCounter, times(1)).add(1.0);
+        verify(asyncFetchSuccessCounter, times(1)).add(anyDouble());
+        verify(asyncFetchFailureCounter, times(1)).add(0.0);
+        verify(asyncFetchFailureCounter, times(1)).add(anyDouble());
 
         // fire a response (with correct round id), wait on reroute incrementing
         test.fireSimulationAndWait(node1.getId());
+        // success counter now goes up by 1 because fetchData completed
+        verify(asyncFetchSuccessCounter, times(2)).add(1.0);
+        verify(asyncFetchSuccessCounter, times(2)).add(anyDouble());
+        verify(asyncFetchFailureCounter, times(1)).add(0.0);
+        verify(asyncFetchFailureCounter, times(1)).add(anyDouble());
+
         // verify we get back the data node
         assertThat(test.reroute.get(), equalTo(2));
         fetchData = test.fetchData(nodes, emptyMap());
         assertThat(fetchData.hasData(), equalTo(true));
         assertThat(fetchData.getData().size(), equalTo(1));
         assertThat(fetchData.getData().get(node1), sameInstance(response1));
+        // total counter remains same because fetchdata does not trigger new async fetch
+        verify(asyncFetchSuccessCounter, times(2)).add(1.0);
+        verify(asyncFetchSuccessCounter, times(2)).add(anyDouble());
+        verify(asyncFetchFailureCounter, times(1)).add(0.0);
+        verify(asyncFetchFailureCounter, times(1)).add(anyDouble());
     }
 
     public void testIgnoreFailureFromDifferentRound() throws Exception {
@@ -198,6 +287,9 @@ public void testIgnoreFailureFromDifferentRound() throws Exception {
         AsyncShardFetch.FetchResult<Response> fetchData = test.fetchData(nodes, emptyMap());
         assertThat(fetchData.hasData(), equalTo(false));
         assertThat(test.reroute.get(), equalTo(0));
+        // counter 0 because fetchData still ongoing
+        verify(asyncFetchSuccessCounter, times(0)).add(anyDouble());
+        verify(asyncFetchFailureCounter, times(0)).add(anyDouble());
 
         // handle a failure with incorrect round id, wait on reroute incrementing
         test.processAsyncFetch(
@@ -207,14 +299,30 @@ public void testIgnoreFailureFromDifferentRound() throws Exception {
         );
         assertThat(fetchData.hasData(), equalTo(false));
         assertThat(test.reroute.get(), equalTo(1));
+        // success counter called with empty list
+        // failure counter goes up by 1 because of the failure
+        verify(asyncFetchSuccessCounter, times(1)).add(0.0);
+        verify(asyncFetchSuccessCounter, times(1)).add(anyDouble());
+        verify(asyncFetchFailureCounter, times(1)).add(1.0);
+        verify(asyncFetchFailureCounter, times(1)).add(anyDouble());
 
         // fire a response, wait on reroute incrementing
         test.fireSimulationAndWait(node1.getId());
+        // failure counter goes up by 1 because of the failure
+        verify(asyncFetchSuccessCounter, times(1)).add(0.0);
+        verify(asyncFetchSuccessCounter, times(1)).add(anyDouble());
+        verify(asyncFetchFailureCounter, times(2)).add(1.0);
+        verify(asyncFetchFailureCounter, times(2)).add(anyDouble());
         // failure, fetched data exists, but has no data
         assertThat(test.reroute.get(), equalTo(2));
         fetchData = test.fetchData(nodes, emptyMap());
         assertThat(fetchData.hasData(), equalTo(true));
         assertThat(fetchData.getData().size(), equalTo(0));
+        // counters remain same because fetchData does not trigger new async fetch
+        verify(asyncFetchSuccessCounter, times(1)).add(0.0);
+        verify(asyncFetchSuccessCounter, times(1)).add(anyDouble());
+        verify(asyncFetchFailureCounter, times(2)).add(1.0);
+        verify(asyncFetchFailureCounter, times(2)).add(anyDouble());
     }
 
     public void testTwoNodesOnSetup() throws Exception {
@@ -226,16 +334,32 @@ public void testTwoNodesOnSetup() throws Exception {
         AsyncShardFetch.FetchResult<Response> fetchData = test.fetchData(nodes, emptyMap());
         assertThat(fetchData.hasData(), equalTo(false));
         assertThat(test.reroute.get(), equalTo(0));
+        // counter 0 because fetch ongoing
+        verify(asyncFetchSuccessCounter, times(0)).add(anyDouble());
+        verify(asyncFetchFailureCounter, times(0)).add(anyDouble());
 
         // fire the first response, it should trigger a reroute
         test.fireSimulationAndWait(node1.getId());
+        // counter 1 because one fetch completed
+        verify(asyncFetchSuccessCounter, times(1)).add(1.0);
+        verify(asyncFetchSuccessCounter, times(1)).add(anyDouble());
+        verify(asyncFetchFailureCounter, times(0)).add(anyDouble());
+
         // there is still another on going request, so no data
         assertThat(test.getNumberOfInFlightFetches(), equalTo(1));
         fetchData = test.fetchData(nodes, emptyMap());
         assertThat(fetchData.hasData(), equalTo(false));
+        // counter still 1 because fetchData did not trigger new async fetch
+        verify(asyncFetchSuccessCounter, times(1)).add(1.0);
+        verify(asyncFetchSuccessCounter, times(1)).add(anyDouble());
+        verify(asyncFetchFailureCounter, times(0)).add(anyDouble());
 
         // fire the second simulation, this should allow us to get the data
         test.fireSimulationAndWait(node2.getId());
+        // counter 2 because 2 fetches completed
+        verify(asyncFetchSuccessCounter, times(2)).add(1.0);
+        verify(asyncFetchSuccessCounter, times(2)).add(anyDouble());
+        verify(asyncFetchFailureCounter, times(0)).add(anyDouble());
         // no more ongoing requests, we should fetch the data
         assertThat(test.reroute.get(), equalTo(2));
         fetchData = test.fetchData(nodes, emptyMap());
@@ -243,6 +367,10 @@ public void testTwoNodesOnSetup() throws Exception {
         assertThat(fetchData.getData().size(), equalTo(2));
         assertThat(fetchData.getData().get(node1), sameInstance(response1));
         assertThat(fetchData.getData().get(node2), sameInstance(response2));
+        // counter still 2 because fetchData call did not trigger new async fetch
+        verify(asyncFetchSuccessCounter, times(2)).add(1.0);
+        verify(asyncFetchSuccessCounter, times(2)).add(anyDouble());
+        verify(asyncFetchFailureCounter, times(0)).add(anyDouble());
     }
 
     public void testTwoNodesOnSetupAndFailure() throws Exception {
@@ -254,34 +382,59 @@ public void testTwoNodesOnSetupAndFailure() throws Exception {
         AsyncShardFetch.FetchResult<Response> fetchData = test.fetchData(nodes, emptyMap());
         assertThat(fetchData.hasData(), equalTo(false));
         assertThat(test.reroute.get(), equalTo(0));
+        // counter 0 because both fetches ongoing
+        verify(asyncFetchSuccessCounter, times(0)).add(anyDouble());
+        verify(asyncFetchFailureCounter, times(0)).add(anyDouble());
 
         // fire the first response, it should trigger a reroute
         test.fireSimulationAndWait(node1.getId());
         assertThat(test.reroute.get(), equalTo(1));
         fetchData = test.fetchData(nodes, emptyMap());
         assertThat(fetchData.hasData(), equalTo(false));
+        // counter 1 because one fetch completed
+        verify(asyncFetchSuccessCounter, times(1)).add(1.0);
+        verify(asyncFetchSuccessCounter, times(1)).add(anyDouble());
+        verify(asyncFetchFailureCounter, times(0)).add(anyDouble());
 
         // fire the second simulation, this should allow us to get the data
         test.fireSimulationAndWait(node2.getId());
+        // failure counter up by 1 because one fetch failed
+        verify(asyncFetchSuccessCounter, times(1)).add(1.0);
+        verify(asyncFetchSuccessCounter, times(1)).add(anyDouble());
+        verify(asyncFetchFailureCounter, times(1)).add(1.0);
+        verify(asyncFetchFailureCounter, times(1)).add(anyDouble());
         assertThat(test.reroute.get(), equalTo(2));
+
         // since one of those failed, we should only have one entry
         fetchData = test.fetchData(nodes, emptyMap());
         assertThat(fetchData.hasData(), equalTo(true));
         assertThat(fetchData.getData().size(), equalTo(1));
         assertThat(fetchData.getData().get(node1), sameInstance(response1));
+        // success and failure counters same because fetchData did not trigger new async fetch
+        verify(asyncFetchSuccessCounter, times(1)).add(1.0);
+        verify(asyncFetchSuccessCounter, times(1)).add(anyDouble());
+        verify(asyncFetchFailureCounter, times(1)).add(1.0);
+        verify(asyncFetchFailureCounter, times(1)).add(anyDouble());
     }
 
     public void testTwoNodesAddedInBetween() throws Exception {
         DiscoveryNodes nodes = DiscoveryNodes.builder().add(node1).build();
         test.addSimulation(node1.getId(), response1);
 
-        // no fetched data, 2 requests still on going
+        // no fetched data, request still on going
         AsyncShardFetch.FetchResult<Response> fetchData = test.fetchData(nodes, emptyMap());
         assertThat(fetchData.hasData(), equalTo(false));
         assertThat(test.reroute.get(), equalTo(0));
+        // counter 0 because both fetches ongoing
+        verify(asyncFetchSuccessCounter, times(0)).add(anyDouble());
+        verify(asyncFetchFailureCounter, times(0)).add(anyDouble());
 
         // fire the first response, it should trigger a reroute
         test.fireSimulationAndWait(node1.getId());
+        // counter 1 because fetch completed
+        verify(asyncFetchSuccessCounter, times(1)).add(1.0);
+        verify(asyncFetchSuccessCounter, times(1)).add(anyDouble());
+        verify(asyncFetchFailureCounter, times(0)).add(anyDouble());
 
         // now, add a second node to the nodes, it should add it to the ongoing requests
         nodes = DiscoveryNodes.builder(nodes).add(node2).build();
@@ -289,16 +442,28 @@ public void testTwoNodesAddedInBetween() throws Exception {
         // no fetch data, has a new node introduced
         fetchData = test.fetchData(nodes, emptyMap());
         assertThat(fetchData.hasData(), equalTo(false));
+        // counter still 1 because second fetch ongoing
+        verify(asyncFetchSuccessCounter, times(1)).add(1.0);
+        verify(asyncFetchSuccessCounter, times(1)).add(anyDouble());
+        verify(asyncFetchFailureCounter, times(0)).add(anyDouble());
 
         // fire the second simulation, this should allow us to get the data
         test.fireSimulationAndWait(node2.getId());
+        // counter now 2 because 2 fetches completed
+        verify(asyncFetchSuccessCounter, times(2)).add(1.0);
+        verify(asyncFetchSuccessCounter, times(2)).add(anyDouble());
+        verify(asyncFetchFailureCounter, times(0)).add(anyDouble());
 
-        // since one of those failed, we should only have one entry
+        // since both succeeded, we should have 2 entries
         fetchData = test.fetchData(nodes, emptyMap());
         assertThat(fetchData.hasData(), equalTo(true));
         assertThat(fetchData.getData().size(), equalTo(2));
         assertThat(fetchData.getData().get(node1), sameInstance(response1));
         assertThat(fetchData.getData().get(node2), sameInstance(response2));
+        // counter still 2 because fetchData did not trigger new async fetch
+        verify(asyncFetchSuccessCounter, times(2)).add(1.0);
+        verify(asyncFetchSuccessCounter, times(2)).add(anyDouble());
+        verify(asyncFetchFailureCounter, times(0)).add(anyDouble());
     }
 
     public void testClearCache() throws Exception {
@@ -312,21 +477,36 @@ public void testClearCache() throws Exception {
         AsyncShardFetch.FetchResult<Response> fetchData = test.fetchData(nodes, emptyMap());
         assertThat(fetchData.hasData(), equalTo(false));
         assertThat(test.reroute.get(), equalTo(0));
+        // counter 0 because fetch ongoing
+        verify(asyncFetchSuccessCounter, times(0)).add(anyDouble());
+        verify(asyncFetchFailureCounter, times(0)).add(anyDouble());
 
         test.fireSimulationAndWait(node1.getId());
         assertThat(test.reroute.get(), equalTo(1));
+        // counter 1 because 1 fetch completed
+        verify(asyncFetchSuccessCounter, times(1)).add(1.0);
+        verify(asyncFetchSuccessCounter, times(1)).add(anyDouble());
+        verify(asyncFetchFailureCounter, times(0)).add(anyDouble());
 
         // verify we get back right data from node
         fetchData = test.fetchData(nodes, emptyMap());
         assertThat(fetchData.hasData(), equalTo(true));
         assertThat(fetchData.getData().size(), equalTo(1));
         assertThat(fetchData.getData().get(node1), sameInstance(response1));
+        // counter still 1 because a new fetch is not called
+        verify(asyncFetchSuccessCounter, times(1)).add(1.0);
+        verify(asyncFetchSuccessCounter, times(1)).add(anyDouble());
+        verify(asyncFetchFailureCounter, times(0)).add(anyDouble());
 
         // second fetch gets same data
         fetchData = test.fetchData(nodes, emptyMap());
         assertThat(fetchData.hasData(), equalTo(true));
         assertThat(fetchData.getData().size(), equalTo(1));
         assertThat(fetchData.getData().get(node1), sameInstance(response1));
+        // counter still 1 because a new fetch is not called
+        verify(asyncFetchSuccessCounter, times(1)).add(1.0);
+        verify(asyncFetchSuccessCounter, times(1)).add(anyDouble());
+        verify(asyncFetchFailureCounter, times(0)).add(anyDouble());
 
         test.clearCacheForNode(node1.getId());
 
@@ -336,15 +516,27 @@ public void testClearCache() throws Exception {
         // no fetched data, new request on going
         fetchData = test.fetchData(nodes, emptyMap());
         assertThat(fetchData.hasData(), equalTo(false));
+        // counter still 1 because new fetch is still ongoing
+        verify(asyncFetchSuccessCounter, times(1)).add(1.0);
+        verify(asyncFetchSuccessCounter, times(1)).add(anyDouble());
+        verify(asyncFetchFailureCounter, times(0)).add(anyDouble());
 
         test.fireSimulationAndWait(node1.getId());
         assertThat(test.reroute.get(), equalTo(2));
+        // counter now 2 because second fetch completed
+        verify(asyncFetchSuccessCounter, times(2)).add(1.0);
+        verify(asyncFetchSuccessCounter, times(2)).add(anyDouble());
+        verify(asyncFetchFailureCounter, times(0)).add(anyDouble());
 
         // verify we get new data back
         fetchData = test.fetchData(nodes, emptyMap());
         assertThat(fetchData.hasData(), equalTo(true));
         assertThat(fetchData.getData().size(), equalTo(1));
         assertThat(fetchData.getData().get(node1), sameInstance(response1_2));
+        // counter still 2 because fetchData did not trigger new async fetch
+        verify(asyncFetchSuccessCounter, times(2)).add(1.0);
+        verify(asyncFetchSuccessCounter, times(2)).add(anyDouble());
+        verify(asyncFetchFailureCounter, times(0)).add(anyDouble());
     }
 
     public void testConcurrentRequestAndClearCache() throws Exception {
@@ -355,12 +547,19 @@ public void testConcurrentRequestAndClearCache() throws Exception {
         AsyncShardFetch.FetchResult<Response> fetchData = test.fetchData(nodes, emptyMap());
         assertThat(fetchData.hasData(), equalTo(false));
         assertThat(test.reroute.get(), equalTo(0));
+        // counter 0 because fetch ongoing
+        verify(asyncFetchSuccessCounter, times(0)).add(anyDouble());
+        verify(asyncFetchFailureCounter, times(0)).add(anyDouble());
 
         // clear cache while request is still on going, before it is processed
         test.clearCacheForNode(node1.getId());
 
         test.fireSimulationAndWait(node1.getId());
         assertThat(test.reroute.get(), equalTo(1));
+        // counter 1 because fetch completed, even though cache was wiped
+        verify(asyncFetchSuccessCounter, times(1)).add(1.0);
+        verify(asyncFetchSuccessCounter, times(1)).add(anyDouble());
+        verify(asyncFetchFailureCounter, times(0)).add(anyDouble());
 
         // prepare next request
         test.addSimulation(node1.getId(), response1_2);
@@ -368,15 +567,27 @@ public void testConcurrentRequestAndClearCache() throws Exception {
         // verify still no fetched data, request still on going
         fetchData = test.fetchData(nodes, emptyMap());
         assertThat(fetchData.hasData(), equalTo(false));
+        // counter unchanged because fetch ongoing
+        verify(asyncFetchSuccessCounter, times(1)).add(1.0);
+        verify(asyncFetchSuccessCounter, times(1)).add(anyDouble());
+        verify(asyncFetchFailureCounter, times(0)).add(anyDouble());
 
         test.fireSimulationAndWait(node1.getId());
         assertThat(test.reroute.get(), equalTo(2));
+        // counter 2 because second fetch completed
+        verify(asyncFetchSuccessCounter, times(2)).add(1.0);
+        verify(asyncFetchSuccessCounter, times(2)).add(anyDouble());
+        verify(asyncFetchFailureCounter, times(0)).add(anyDouble());
 
         // verify we get new data back
         fetchData = test.fetchData(nodes, emptyMap());
         assertThat(fetchData.hasData(), equalTo(true));
         assertThat(fetchData.getData().size(), equalTo(1));
         assertThat(fetchData.getData().get(node1), sameInstance(response1_2));
+        // counter unchanged because fetchData does not trigger new async fetch
+        verify(asyncFetchSuccessCounter, times(2)).add(1.0);
+        verify(asyncFetchSuccessCounter, times(2)).add(anyDouble());
+        verify(asyncFetchFailureCounter, times(0)).add(anyDouble());
 
     }
 
@@ -398,8 +609,15 @@ static class Entry {
         private final Map<String, Entry> simulations = new ConcurrentHashMap<>();
         private AtomicInteger reroute = new AtomicInteger();
 
-        TestFetch(ThreadPool threadPool) {
-            super(LogManager.getLogger(TestFetch.class), "test", new ShardId("test", "_na_", 1), "", null);
+        TestFetch(ThreadPool threadPool, MetricsRegistry metricsRegistry) {
+            super(
+                LogManager.getLogger(TestFetch.class),
+                "test",
+                new ShardId("test", "_na_", 1),
+                "",
+                null,
+                new ClusterManagerMetrics(metricsRegistry)
+            );
             this.threadPool = threadPool;
         }
 
diff --git a/server/src/test/java/org/opensearch/gateway/ShardBatchCacheTests.java b/server/src/test/java/org/opensearch/gateway/ShardBatchCacheTests.java
index 12030ad41d508..39c4ee8c8ca06 100644
--- a/server/src/test/java/org/opensearch/gateway/ShardBatchCacheTests.java
+++ b/server/src/test/java/org/opensearch/gateway/ShardBatchCacheTests.java
@@ -8,6 +8,7 @@
 
 package org.opensearch.gateway;
 
+import org.opensearch.cluster.ClusterManagerMetrics;
 import org.opensearch.cluster.OpenSearchAllocationTestCase;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNodes;
@@ -19,6 +20,7 @@
 import org.opensearch.gateway.TransportNodesGatewayStartedShardHelper.GatewayStartedShard;
 import org.opensearch.gateway.TransportNodesListGatewayStartedShardsBatch.NodeGatewayStartedShardsBatch;
 import org.opensearch.indices.store.ShardAttributes;
+import org.opensearch.telemetry.metrics.noop.NoopMetricsRegistry;
 
 import java.util.ArrayList;
 import java.util.HashMap;
@@ -52,7 +54,8 @@ public void setupShardBatchCache(String batchId, int numberOfShards) {
             GatewayStartedShard.class,
             new GatewayStartedShard(null, false, null, null),
             GatewayStartedShard::isEmpty,
-            new ShardBatchResponseFactory<>(true)
+            new ShardBatchResponseFactory<>(true),
+            new ClusterManagerMetrics(NoopMetricsRegistry.INSTANCE)
         );
     }
 
diff --git a/server/src/test/java/org/opensearch/gateway/remote/ClusterMetadataManifestTests.java b/server/src/test/java/org/opensearch/gateway/remote/ClusterMetadataManifestTests.java
index 3f9aa1245cab3..09c2933680be3 100644
--- a/server/src/test/java/org/opensearch/gateway/remote/ClusterMetadataManifestTests.java
+++ b/server/src/test/java/org/opensearch/gateway/remote/ClusterMetadataManifestTests.java
@@ -34,6 +34,9 @@
 import org.opensearch.gateway.remote.ClusterMetadataManifest.UploadedMetadataAttribute;
 import org.opensearch.test.EqualsHashCodeTestUtils;
 import org.opensearch.test.OpenSearchTestCase;
+import org.opensearch.threadpool.TestThreadPool;
+import org.opensearch.threadpool.ThreadPool;
+import org.junit.After;
 
 import java.io.IOException;
 import java.util.ArrayList;
@@ -64,6 +67,14 @@
 
 public class ClusterMetadataManifestTests extends OpenSearchTestCase {
 
+    private final ThreadPool threadPool = new TestThreadPool(getClass().getName());
+
+    @After
+    public void teardown() throws Exception {
+        super.tearDown();
+        threadPool.shutdown();
+    }
+
     public void testClusterMetadataManifestXContentV0() throws IOException {
         UploadedIndexMetadata uploadedIndexMetadata = new UploadedIndexMetadata("test-index", "test-uuid", "/test/upload/path", CODEC_V0);
         ClusterMetadataManifest originalManifest = ClusterMetadataManifest.builder()
@@ -214,7 +225,7 @@ public void testClusterMetadataManifestSerializationEqualsHashCode() {
                     "indicesRoutingDiffPath"
                 )
             )
-            .checksum(new ClusterStateChecksum(createClusterState()))
+            .checksum(new ClusterStateChecksum(createClusterState(), threadPool))
             .build();
         {  // Mutate Cluster Term
             EqualsHashCodeTestUtils.checkEqualsAndHashCode(
@@ -647,7 +658,7 @@ public void testClusterMetadataManifestXContentV4() throws IOException {
         UploadedIndexMetadata uploadedIndexMetadata = new UploadedIndexMetadata("test-index", "test-uuid", "/test/upload/path");
         UploadedMetadataAttribute uploadedMetadataAttribute = new UploadedMetadataAttribute("attribute_name", "testing_attribute");
         final StringKeyDiffProvider<IndexRoutingTable> routingTableIncrementalDiff = Mockito.mock(StringKeyDiffProvider.class);
-        ClusterStateChecksum checksum = new ClusterStateChecksum(createClusterState());
+        ClusterStateChecksum checksum = new ClusterStateChecksum(createClusterState(), threadPool);
         ClusterMetadataManifest originalManifest = ClusterMetadataManifest.builder()
             .clusterTerm(1L)
             .stateVersion(1L)
diff --git a/server/src/test/java/org/opensearch/gateway/remote/ClusterStateChecksumTests.java b/server/src/test/java/org/opensearch/gateway/remote/ClusterStateChecksumTests.java
index 0203e56dd2d5c..9b98187053a39 100644
--- a/server/src/test/java/org/opensearch/gateway/remote/ClusterStateChecksumTests.java
+++ b/server/src/test/java/org/opensearch/gateway/remote/ClusterStateChecksumTests.java
@@ -34,6 +34,9 @@
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.core.xcontent.XContentParser;
 import org.opensearch.test.OpenSearchTestCase;
+import org.opensearch.threadpool.TestThreadPool;
+import org.opensearch.threadpool.ThreadPool;
+import org.junit.After;
 
 import java.io.IOException;
 import java.util.EnumSet;
@@ -41,14 +44,21 @@
 import java.util.Map;
 
 public class ClusterStateChecksumTests extends OpenSearchTestCase {
+    private final ThreadPool threadPool = new TestThreadPool(getClass().getName());
+
+    @After
+    public void teardown() throws Exception {
+        super.tearDown();
+        threadPool.shutdown();
+    }
 
     public void testClusterStateChecksumEmptyClusterState() {
-        ClusterStateChecksum checksum = new ClusterStateChecksum(ClusterState.EMPTY_STATE);
+        ClusterStateChecksum checksum = new ClusterStateChecksum(ClusterState.EMPTY_STATE, threadPool);
         assertNotNull(checksum);
     }
 
     public void testClusterStateChecksum() {
-        ClusterStateChecksum checksum = new ClusterStateChecksum(generateClusterState());
+        ClusterStateChecksum checksum = new ClusterStateChecksum(generateClusterState(), threadPool);
         assertNotNull(checksum);
         assertTrue(checksum.routingTableChecksum != 0);
         assertTrue(checksum.nodesChecksum != 0);
@@ -65,8 +75,8 @@ public void testClusterStateChecksum() {
     }
 
     public void testClusterStateMatchChecksum() {
-        ClusterStateChecksum checksum = new ClusterStateChecksum(generateClusterState());
-        ClusterStateChecksum newChecksum = new ClusterStateChecksum(generateClusterState());
+        ClusterStateChecksum checksum = new ClusterStateChecksum(generateClusterState(), threadPool);
+        ClusterStateChecksum newChecksum = new ClusterStateChecksum(generateClusterState(), threadPool);
         assertNotNull(checksum);
         assertNotNull(newChecksum);
         assertEquals(checksum.routingTableChecksum, newChecksum.routingTableChecksum);
@@ -84,7 +94,7 @@ public void testClusterStateMatchChecksum() {
     }
 
     public void testXContentConversion() throws IOException {
-        ClusterStateChecksum checksum = new ClusterStateChecksum(generateClusterState());
+        ClusterStateChecksum checksum = new ClusterStateChecksum(generateClusterState(), threadPool);
         final XContentBuilder builder = JsonXContent.contentBuilder();
         builder.startObject();
         checksum.toXContent(builder, ToXContent.EMPTY_PARAMS);
@@ -97,7 +107,7 @@ public void testXContentConversion() throws IOException {
     }
 
     public void testSerialization() throws IOException {
-        ClusterStateChecksum checksum = new ClusterStateChecksum(generateClusterState());
+        ClusterStateChecksum checksum = new ClusterStateChecksum(generateClusterState(), threadPool);
         BytesStreamOutput output = new BytesStreamOutput();
         checksum.writeTo(output);
 
@@ -109,10 +119,10 @@ public void testSerialization() throws IOException {
 
     public void testGetMismatchEntities() {
         ClusterState clsState1 = generateClusterState();
-        ClusterStateChecksum checksum = new ClusterStateChecksum(clsState1);
+        ClusterStateChecksum checksum = new ClusterStateChecksum(clsState1, threadPool);
         assertTrue(checksum.getMismatchEntities(checksum).isEmpty());
 
-        ClusterStateChecksum checksum2 = new ClusterStateChecksum(clsState1);
+        ClusterStateChecksum checksum2 = new ClusterStateChecksum(clsState1, threadPool);
         assertTrue(checksum.getMismatchEntities(checksum2).isEmpty());
 
         ClusterState clsState2 = ClusterState.builder(ClusterName.DEFAULT)
@@ -122,7 +132,7 @@ public void testGetMismatchEntities() {
             .customs(Map.of())
             .metadata(Metadata.EMPTY_METADATA)
             .build();
-        ClusterStateChecksum checksum3 = new ClusterStateChecksum(clsState2);
+        ClusterStateChecksum checksum3 = new ClusterStateChecksum(clsState2, threadPool);
         List<String> mismatches = checksum.getMismatchEntities(checksum3);
         assertFalse(mismatches.isEmpty());
         assertEquals(11, mismatches.size());
@@ -151,8 +161,8 @@ public void testGetMismatchEntitiesUnorderedInput() {
         ClusterState state2 = ClusterState.builder(state1).nodes(nodes1).build();
         ClusterState state3 = ClusterState.builder(state1).nodes(nodes2).build();
 
-        ClusterStateChecksum checksum1 = new ClusterStateChecksum(state2);
-        ClusterStateChecksum checksum2 = new ClusterStateChecksum(state3);
+        ClusterStateChecksum checksum1 = new ClusterStateChecksum(state2, threadPool);
+        ClusterStateChecksum checksum2 = new ClusterStateChecksum(state3, threadPool);
         assertEquals(checksum2, checksum1);
     }
 
diff --git a/server/src/test/java/org/opensearch/gateway/remote/RemoteClusterStateServiceTests.java b/server/src/test/java/org/opensearch/gateway/remote/RemoteClusterStateServiceTests.java
index 56857285fa8d3..35a8ae16cacf7 100644
--- a/server/src/test/java/org/opensearch/gateway/remote/RemoteClusterStateServiceTests.java
+++ b/server/src/test/java/org/opensearch/gateway/remote/RemoteClusterStateServiceTests.java
@@ -3123,7 +3123,7 @@ public void testWriteFullMetadataSuccessWithChecksumValidationEnabled() throws I
             .previousClusterUUID("prev-cluster-uuid")
             .routingTableVersion(1L)
             .indicesRouting(List.of(uploadedIndiceRoutingMetadata))
-            .checksum(new ClusterStateChecksum(clusterState))
+            .checksum(new ClusterStateChecksum(clusterState, threadPool))
             .build();
 
         assertThat(manifest.getIndices().size(), is(1));
@@ -3193,7 +3193,7 @@ public void testWriteIncrementalMetadataSuccessWithChecksumValidationEnabled() t
 
         final ClusterMetadataManifest previousManifest = ClusterMetadataManifest.builder()
             .indices(Collections.emptyList())
-            .checksum(new ClusterStateChecksum(clusterState))
+            .checksum(new ClusterStateChecksum(clusterState, threadPool))
             .build();
         when((blobStoreRepository.basePath())).thenReturn(BlobPath.cleanPath().add("base-path"));
 
@@ -3219,7 +3219,7 @@ public void testWriteIncrementalMetadataSuccessWithChecksumValidationEnabled() t
             .previousClusterUUID("prev-cluster-uuid")
             .routingTableVersion(1)
             .indicesRouting(List.of(uploadedIndiceRoutingMetadata))
-            .checksum(new ClusterStateChecksum(clusterState))
+            .checksum(new ClusterStateChecksum(clusterState, threadPool))
             .build();
 
         assertThat(manifest.getIndices().size(), is(1));
@@ -3245,7 +3245,7 @@ public void testWriteIncrementalMetadataSuccessWithChecksumValidationModeNone()
 
         final ClusterMetadataManifest previousManifest = ClusterMetadataManifest.builder()
             .indices(Collections.emptyList())
-            .checksum(new ClusterStateChecksum(clusterState))
+            .checksum(new ClusterStateChecksum(clusterState, threadPool))
             .build();
         when((blobStoreRepository.basePath())).thenReturn(BlobPath.cleanPath().add("base-path"));
 
@@ -3271,7 +3271,7 @@ public void testWriteIncrementalMetadataSuccessWithChecksumValidationModeNone()
             .previousClusterUUID("prev-cluster-uuid")
             .routingTableVersion(1)
             .indicesRouting(List.of(uploadedIndiceRoutingMetadata))
-            .checksum(new ClusterStateChecksum(clusterState))
+            .checksum(new ClusterStateChecksum(clusterState, threadPool))
             .build();
 
         assertThat(manifest.getIndices().size(), is(1));
@@ -3349,7 +3349,7 @@ public void testGetClusterStateForManifestWithChecksumValidationEnabled() throws
         initializeWithChecksumEnabled(RemoteClusterStateService.RemoteClusterStateValidationMode.FAILURE);
         ClusterState clusterState = generateClusterStateWithAllAttributes().build();
         ClusterMetadataManifest manifest = generateClusterMetadataManifestWithAllAttributes().checksum(
-            new ClusterStateChecksum(clusterState)
+            new ClusterStateChecksum(clusterState, threadPool)
         ).build();
         remoteClusterStateService.start();
         RemoteClusterStateService mockService = spy(remoteClusterStateService);
@@ -3382,7 +3382,7 @@ public void testGetClusterStateForManifestWithChecksumValidationModeNone() throw
         initializeWithChecksumEnabled(RemoteClusterStateService.RemoteClusterStateValidationMode.NONE);
         ClusterState clusterState = generateClusterStateWithAllAttributes().build();
         ClusterMetadataManifest manifest = generateClusterMetadataManifestWithAllAttributes().checksum(
-            new ClusterStateChecksum(clusterState)
+            new ClusterStateChecksum(clusterState, threadPool)
         ).build();
         remoteClusterStateService.start();
         RemoteClusterStateService mockService = spy(remoteClusterStateService);
@@ -3415,7 +3415,7 @@ public void testGetClusterStateForManifestWithChecksumValidationEnabledWithMisma
         initializeWithChecksumEnabled(RemoteClusterStateService.RemoteClusterStateValidationMode.FAILURE);
         ClusterState clusterState = generateClusterStateWithAllAttributes().build();
         ClusterMetadataManifest manifest = generateClusterMetadataManifestWithAllAttributes().checksum(
-            new ClusterStateChecksum(clusterState)
+            new ClusterStateChecksum(clusterState, threadPool)
         ).build();
         remoteClusterStateService.start();
         RemoteClusterStateService mockService = spy(remoteClusterStateService);
@@ -3465,7 +3465,7 @@ public void testGetClusterStateForManifestWithChecksumValidationDebugWithMismatc
         );
         ClusterState clusterState = generateClusterStateWithAllAttributes().build();
         ClusterMetadataManifest manifest = generateClusterMetadataManifestWithAllAttributes().checksum(
-            new ClusterStateChecksum(clusterState)
+            new ClusterStateChecksum(clusterState, threadPool)
         ).build();
         remoteClusterStateService.start();
         RemoteClusterStateService mockService = spy(remoteClusterStateService);
@@ -3505,7 +3505,7 @@ public void testGetClusterStateUsingDiffWithChecksum() throws IOException {
         initializeWithChecksumEnabled(RemoteClusterStateService.RemoteClusterStateValidationMode.FAILURE);
         ClusterState clusterState = generateClusterStateWithAllAttributes().build();
         ClusterMetadataManifest manifest = generateClusterMetadataManifestWithAllAttributes().checksum(
-            new ClusterStateChecksum(clusterState)
+            new ClusterStateChecksum(clusterState, threadPool)
         ).diffManifest(ClusterStateDiffManifest.builder().build()).build();
 
         remoteClusterStateService.start();
@@ -3547,7 +3547,7 @@ public void testGetClusterStateUsingDiffWithChecksumModeNone() throws IOExceptio
         initializeWithChecksumEnabled(RemoteClusterStateService.RemoteClusterStateValidationMode.NONE);
         ClusterState clusterState = generateClusterStateWithAllAttributes().build();
         ClusterMetadataManifest manifest = generateClusterMetadataManifestWithAllAttributes().checksum(
-            new ClusterStateChecksum(clusterState)
+            new ClusterStateChecksum(clusterState, threadPool)
         ).diffManifest(ClusterStateDiffManifest.builder().build()).build();
 
         remoteClusterStateService.start();
@@ -3589,7 +3589,7 @@ public void testGetClusterStateUsingDiffWithChecksumModeDebugMismatch() throws I
         initializeWithChecksumEnabled(RemoteClusterStateService.RemoteClusterStateValidationMode.DEBUG);
         ClusterState clusterState = generateClusterStateWithAllAttributes().build();
         ClusterMetadataManifest manifest = generateClusterMetadataManifestWithAllAttributes().checksum(
-            new ClusterStateChecksum(clusterState)
+            new ClusterStateChecksum(clusterState, threadPool)
         ).diffManifest(ClusterStateDiffManifest.builder().build()).build();
 
         remoteClusterStateService.start();
@@ -3630,7 +3630,7 @@ public void testGetClusterStateUsingDiffWithChecksumModeTraceMismatch() throws I
         initializeWithChecksumEnabled(RemoteClusterStateService.RemoteClusterStateValidationMode.TRACE);
         ClusterState clusterState = generateClusterStateWithAllAttributes().build();
         ClusterMetadataManifest manifest = generateClusterMetadataManifestWithAllAttributes().checksum(
-            new ClusterStateChecksum(clusterState)
+            new ClusterStateChecksum(clusterState, threadPool)
         ).diffManifest(ClusterStateDiffManifest.builder().build()).build();
 
         remoteClusterStateService.start();
@@ -3692,7 +3692,7 @@ public void testGetClusterStateUsingDiffWithChecksumMismatch() throws IOExceptio
         initializeWithChecksumEnabled(RemoteClusterStateService.RemoteClusterStateValidationMode.FAILURE);
         ClusterState clusterState = generateClusterStateWithAllAttributes().build();
         ClusterMetadataManifest manifest = generateClusterMetadataManifestWithAllAttributes().checksum(
-            new ClusterStateChecksum(clusterState)
+            new ClusterStateChecksum(clusterState, threadPool)
         ).diffManifest(ClusterStateDiffManifest.builder().build()).build();
 
         remoteClusterStateService.start();
diff --git a/server/src/test/java/org/opensearch/rest/BaseRestHandlerTests.java b/server/src/test/java/org/opensearch/rest/BaseRestHandlerTests.java
index 45653e9d8e4d6..7534dcd93944a 100644
--- a/server/src/test/java/org/opensearch/rest/BaseRestHandlerTests.java
+++ b/server/src/test/java/org/opensearch/rest/BaseRestHandlerTests.java
@@ -35,6 +35,8 @@
 import org.opensearch.client.node.NodeClient;
 import org.opensearch.common.Table;
 import org.opensearch.common.settings.Settings;
+import org.opensearch.core.common.bytes.BytesArray;
+import org.opensearch.core.rest.RestStatus;
 import org.opensearch.rest.RestHandler.ReplacedRoute;
 import org.opensearch.rest.RestHandler.Route;
 import org.opensearch.rest.RestRequest.Method;
@@ -46,15 +48,22 @@
 import org.opensearch.threadpool.ThreadPool;
 
 import java.io.IOException;
+import java.lang.reflect.Modifier;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Set;
 import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.stream.Collectors;
 
 import static org.hamcrest.core.StringContains.containsString;
 import static org.hamcrest.object.HasToString.hasToString;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
 
 public class BaseRestHandlerTests extends OpenSearchTestCase {
     private NodeClient mockClient;
@@ -288,4 +297,36 @@ public void testReplaceRoutesMethod() throws Exception {
         }
     }
 
+    public void testRestHandlerWrapper() throws Exception {
+        RestHandler rh = new RestHandler() {
+            @Override
+            public void handleRequest(RestRequest request, RestChannel channel, NodeClient client) throws Exception {
+                new BytesRestResponse(RestStatus.OK, BytesRestResponse.TEXT_CONTENT_TYPE, BytesArray.EMPTY);
+            }
+        };
+        RestHandler handlerSpy = spy(rh);
+        RestHandler.Wrapper rhWrapper = new RestHandler.Wrapper(handlerSpy);
+
+        List<java.lang.reflect.Method> overridableMethods = Arrays.stream(RestHandler.class.getMethods())
+            .filter(
+                m -> !(Modifier.isPrivate(m.getModifiers()) || Modifier.isStatic(m.getModifiers()) || Modifier.isFinal(m.getModifiers()))
+            )
+            .collect(Collectors.toList());
+
+        for (java.lang.reflect.Method method : overridableMethods) {
+            int argCount = method.getParameterCount();
+            Object[] args = new Object[argCount];
+            for (int i = 0; i < argCount; i++) {
+                args[i] = any();
+            }
+            if (args.length > 0) {
+                method.invoke(rhWrapper, args);
+            } else {
+                method.invoke(rhWrapper);
+            }
+            method.invoke(verify(handlerSpy, times(1)), args);
+        }
+        verifyNoMoreInteractions(handlerSpy);
+    }
+
 }
diff --git a/server/src/test/java/org/opensearch/rest/action/cat/RestIndicesActionTests.java b/server/src/test/java/org/opensearch/rest/action/cat/RestIndicesActionTests.java
index 96b1c75371697..2debb00a0d14f 100644
--- a/server/src/test/java/org/opensearch/rest/action/cat/RestIndicesActionTests.java
+++ b/server/src/test/java/org/opensearch/rest/action/cat/RestIndicesActionTests.java
@@ -43,13 +43,19 @@
 import org.opensearch.cluster.routing.TestShardRouting;
 import org.opensearch.common.Table;
 import org.opensearch.common.UUIDs;
+import org.opensearch.common.breaker.ResponseLimitSettings;
+import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.core.index.Index;
 import org.opensearch.core.index.shard.ShardId;
 import org.opensearch.index.IndexSettings;
+import org.opensearch.rest.action.list.RestIndicesListAction;
+import org.opensearch.rest.pagination.PageToken;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.test.rest.FakeRestRequest;
+import org.junit.Before;
 
+import java.util.ArrayList;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Locale;
@@ -63,13 +69,14 @@
 
 public class RestIndicesActionTests extends OpenSearchTestCase {
 
-    public void testBuildTable() {
-        final int numIndices = randomIntBetween(3, 20);
-        final Map<String, Settings> indicesSettings = new LinkedHashMap<>();
-        final Map<String, IndexMetadata> indicesMetadatas = new LinkedHashMap<>();
-        final Map<String, ClusterIndexHealth> indicesHealths = new LinkedHashMap<>();
-        final Map<String, IndexStats> indicesStats = new LinkedHashMap<>();
+    final Map<String, Settings> indicesSettings = new LinkedHashMap<>();
+    final Map<String, IndexMetadata> indicesMetadatas = new LinkedHashMap<>();
+    final Map<String, ClusterIndexHealth> indicesHealths = new LinkedHashMap<>();
+    final Map<String, IndexStats> indicesStats = new LinkedHashMap<>();
 
+    @Before
+    public void setup() {
+        final int numIndices = randomIntBetween(3, 20);
         for (int i = 0; i < numIndices; i++) {
             String indexName = "index-" + i;
 
@@ -136,11 +143,65 @@ public void testBuildTable() {
                 }
             }
         }
+    }
 
-        final RestIndicesAction action = new RestIndicesAction();
-        final Table table = action.buildTable(new FakeRestRequest(), indicesSettings, indicesHealths, indicesStats, indicesMetadatas);
+    public void testBuildTable() {
+        final ClusterSettings clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        final Settings settings = Settings.builder().build();
+        final ResponseLimitSettings responseLimitSettings = new ResponseLimitSettings(clusterSettings, settings);
+        final RestIndicesAction action = new RestIndicesAction(responseLimitSettings);
+        final Table table = action.buildTable(
+            new FakeRestRequest(),
+            indicesSettings,
+            indicesHealths,
+            indicesStats,
+            indicesMetadatas,
+            action.getTableIterator(new String[0], indicesSettings),
+            null
+        );
 
         // now, verify the table is correct
+        assertNotNull(table);
+
+        assertTableHeaders(table);
+
+        assertThat(table.getRows().size(), equalTo(indicesMetadatas.size()));
+        assertTableRows(table);
+    }
+
+    public void testBuildPaginatedTable() {
+        final ClusterSettings clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        final Settings settings = Settings.builder().build();
+        final ResponseLimitSettings responseLimitSettings = new ResponseLimitSettings(clusterSettings, settings);
+        final RestIndicesAction action = new RestIndicesAction(responseLimitSettings);
+        final RestIndicesListAction indicesListAction = new RestIndicesListAction(responseLimitSettings);
+        List<String> indicesList = new ArrayList<>(indicesMetadatas.keySet());
+        // Using half of the indices from metadata list for a page
+        String[] indicesToBeQueried = indicesList.subList(0, indicesMetadatas.size() / 2).toArray(new String[0]);
+        PageToken pageToken = new PageToken("foo", "indices");
+        final Table table = action.buildTable(
+            new FakeRestRequest(),
+            indicesSettings,
+            indicesHealths,
+            indicesStats,
+            indicesMetadatas,
+            indicesListAction.getTableIterator(indicesToBeQueried, indicesSettings),
+            pageToken
+        );
+
+        // verifying table
+        assertNotNull(table);
+        assertTableHeaders(table);
+        assertNotNull(table.getPageToken());
+        assertEquals(pageToken.getNextToken(), table.getPageToken().getNextToken());
+        assertEquals(pageToken.getPaginatedEntity(), table.getPageToken().getPaginatedEntity());
+
+        // Table should only contain the indices present in indicesToBeQueried
+        assertThat(table.getRows().size(), equalTo(indicesMetadatas.size() / 2));
+        assertTableRows(table);
+    }
+
+    private void assertTableHeaders(Table table) {
         List<Table.Cell> headers = table.getHeaders();
         assertThat(headers.get(0).value, equalTo("health"));
         assertThat(headers.get(1).value, equalTo("status"));
@@ -148,9 +209,10 @@ public void testBuildTable() {
         assertThat(headers.get(3).value, equalTo("uuid"));
         assertThat(headers.get(4).value, equalTo("pri"));
         assertThat(headers.get(5).value, equalTo("rep"));
+    }
 
+    private void assertTableRows(Table table) {
         final List<List<Table.Cell>> rows = table.getRows();
-        assertThat(rows.size(), equalTo(indicesMetadatas.size()));
 
         for (final List<Table.Cell> row : rows) {
             final String indexName = (String) row.get(2).value;
diff --git a/server/src/test/java/org/opensearch/rest/action/cat/RestTableTests.java b/server/src/test/java/org/opensearch/rest/action/cat/RestTableTests.java
index 8183cb1d3b910..a82e563d70273 100644
--- a/server/src/test/java/org/opensearch/rest/action/cat/RestTableTests.java
+++ b/server/src/test/java/org/opensearch/rest/action/cat/RestTableTests.java
@@ -37,6 +37,7 @@
 import org.opensearch.core.xcontent.MediaTypeRegistry;
 import org.opensearch.rest.AbstractRestChannel;
 import org.opensearch.rest.RestResponse;
+import org.opensearch.rest.pagination.PageToken;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.test.rest.FakeRestRequest;
 import org.junit.Before;
@@ -64,9 +65,14 @@ public class RestTableTests extends OpenSearchTestCase {
     private static final String ACCEPT = "Accept";
     private static final String TEXT_PLAIN = "text/plain; charset=UTF-8";
     private static final String TEXT_TABLE_BODY = "foo foo foo foo foo foo foo foo\n";
+    private static final String PAGINATED_TEXT_TABLE_BODY = "foo foo foo foo foo foo foo foo\nnext_token foo\n";
     private static final String JSON_TABLE_BODY = "[{\"bulk.foo\":\"foo\",\"bulk.bar\":\"foo\",\"aliasedBulk\":\"foo\","
         + "\"aliasedSecondBulk\":\"foo\",\"unmatched\":\"foo\","
         + "\"invalidAliasesBulk\":\"foo\",\"timestamp\":\"foo\",\"epoch\":\"foo\"}]";
+    private static final String PAGINATED_JSON_TABLE_BODY =
+        "{\"next_token\":\"foo\",\"entities\":[{\"bulk.foo\":\"foo\",\"bulk.bar\":\"foo\",\"aliasedBulk\":\"foo\","
+            + "\"aliasedSecondBulk\":\"foo\",\"unmatched\":\"foo\","
+            + "\"invalidAliasesBulk\":\"foo\",\"timestamp\":\"foo\",\"epoch\":\"foo\"}]}";
     private static final String YAML_TABLE_BODY = "---\n"
         + "- bulk.foo: \"foo\"\n"
         + "  bulk.bar: \"foo\"\n"
@@ -76,6 +82,17 @@ public class RestTableTests extends OpenSearchTestCase {
         + "  invalidAliasesBulk: \"foo\"\n"
         + "  timestamp: \"foo\"\n"
         + "  epoch: \"foo\"\n";
+    private static final String PAGINATED_YAML_TABLE_BODY = "---\n"
+        + "next_token: \"foo\"\n"
+        + "entities:\n"
+        + "- bulk.foo: \"foo\"\n"
+        + "  bulk.bar: \"foo\"\n"
+        + "  aliasedBulk: \"foo\"\n"
+        + "  aliasedSecondBulk: \"foo\"\n"
+        + "  unmatched: \"foo\"\n"
+        + "  invalidAliasesBulk: \"foo\"\n"
+        + "  timestamp: \"foo\"\n"
+        + "  epoch: \"foo\"\n";
     private Table table;
     private FakeRestRequest restRequest;
 
@@ -83,20 +100,7 @@ public class RestTableTests extends OpenSearchTestCase {
     public void setup() {
         restRequest = new FakeRestRequest();
         table = new Table();
-        table.startHeaders();
-        table.addCell("bulk.foo", "alias:f;desc:foo");
-        table.addCell("bulk.bar", "alias:b;desc:bar");
-        // should be matched as well due to the aliases
-        table.addCell("aliasedBulk", "alias:bulkWhatever;desc:bar");
-        table.addCell("aliasedSecondBulk", "alias:foobar,bulkolicious,bulkotastic;desc:bar");
-        // no match
-        table.addCell("unmatched", "alias:un.matched;desc:bar");
-        // invalid alias
-        table.addCell("invalidAliasesBulk", "alias:,,,;desc:bar");
-        // timestamp
-        table.addCell("timestamp", "alias:ts");
-        table.addCell("epoch", "alias:t");
-        table.endHeaders();
+        addHeaders(table);
     }
 
     public void testThatDisplayHeadersSupportWildcards() throws Exception {
@@ -121,10 +125,28 @@ public void testThatWeUseTheAcceptHeaderJson() throws Exception {
         assertResponse(Collections.singletonMap(ACCEPT, Collections.singletonList(APPLICATION_JSON)), APPLICATION_JSON, JSON_TABLE_BODY);
     }
 
+    public void testThatWeUseTheAcceptHeaderJsonForPaginatedTable() throws Exception {
+        assertResponse(
+            Collections.singletonMap(ACCEPT, Collections.singletonList(APPLICATION_JSON)),
+            APPLICATION_JSON,
+            PAGINATED_JSON_TABLE_BODY,
+            getPaginatedTable()
+        );
+    }
+
     public void testThatWeUseTheAcceptHeaderYaml() throws Exception {
         assertResponse(Collections.singletonMap(ACCEPT, Collections.singletonList(APPLICATION_YAML)), APPLICATION_YAML, YAML_TABLE_BODY);
     }
 
+    public void testThatWeUseTheAcceptHeaderYamlForPaginatedTable() throws Exception {
+        assertResponse(
+            Collections.singletonMap(ACCEPT, Collections.singletonList(APPLICATION_YAML)),
+            APPLICATION_YAML,
+            PAGINATED_YAML_TABLE_BODY,
+            getPaginatedTable()
+        );
+    }
+
     public void testThatWeUseTheAcceptHeaderSmile() throws Exception {
         assertResponseContentType(Collections.singletonMap(ACCEPT, Collections.singletonList(APPLICATION_SMILE)), APPLICATION_SMILE);
     }
@@ -137,6 +159,15 @@ public void testThatWeUseTheAcceptHeaderText() throws Exception {
         assertResponse(Collections.singletonMap(ACCEPT, Collections.singletonList(TEXT_PLAIN)), TEXT_PLAIN, TEXT_TABLE_BODY);
     }
 
+    public void testThatWeUseTheAcceptHeaderTextForPaginatedTable() throws Exception {
+        assertResponse(
+            Collections.singletonMap(ACCEPT, Collections.singletonList(TEXT_PLAIN)),
+            TEXT_PLAIN,
+            PAGINATED_TEXT_TABLE_BODY,
+            getPaginatedTable()
+        );
+    }
+
     public void testIgnoreContentType() throws Exception {
         assertResponse(Collections.singletonMap(CONTENT_TYPE, Collections.singletonList(APPLICATION_JSON)), TEXT_PLAIN, TEXT_TABLE_BODY);
     }
@@ -261,6 +292,10 @@ public void testMultiSort() {
     }
 
     private RestResponse assertResponseContentType(Map<String, List<String>> headers, String mediaType) throws Exception {
+        return assertResponseContentType(headers, mediaType, table);
+    }
+
+    private RestResponse assertResponseContentType(Map<String, List<String>> headers, String mediaType, Table table) throws Exception {
         FakeRestRequest requestWithAcceptHeader = new FakeRestRequest.Builder(xContentRegistry()).withHeaders(headers).build();
         table.startRow();
         table.addCell("foo");
@@ -282,7 +317,11 @@ public void sendResponse(RestResponse response) {}
     }
 
     private void assertResponse(Map<String, List<String>> headers, String mediaType, String body) throws Exception {
-        RestResponse response = assertResponseContentType(headers, mediaType);
+        assertResponse(headers, mediaType, body, table);
+    }
+
+    private void assertResponse(Map<String, List<String>> headers, String mediaType, String body, Table table) throws Exception {
+        RestResponse response = assertResponseContentType(headers, mediaType, table);
         assertThat(response.content().utf8ToString(), equalTo(body));
     }
 
@@ -294,4 +333,28 @@ private List<String> getHeaderNames(List<RestTable.DisplayHeader> headers) {
 
         return headerNames;
     }
+
+    private Table getPaginatedTable() {
+        PageToken pageToken = new PageToken("foo", "entities");
+        Table paginatedTable = new Table(pageToken);
+        addHeaders(paginatedTable);
+        return paginatedTable;
+    }
+
+    private void addHeaders(Table table) {
+        table.startHeaders();
+        table.addCell("bulk.foo", "alias:f;desc:foo");
+        table.addCell("bulk.bar", "alias:b;desc:bar");
+        // should be matched as well due to the aliases
+        table.addCell("aliasedBulk", "alias:bulkWhatever;desc:bar");
+        table.addCell("aliasedSecondBulk", "alias:foobar,bulkolicious,bulkotastic;desc:bar");
+        // no match
+        table.addCell("unmatched", "alias:un.matched;desc:bar");
+        // invalid alias
+        table.addCell("invalidAliasesBulk", "alias:,,,;desc:bar");
+        // timestamp
+        table.addCell("timestamp", "alias:ts");
+        table.addCell("epoch", "alias:t");
+        table.endHeaders();
+    }
 }
diff --git a/server/src/test/java/org/opensearch/rest/pagination/IndexPaginationStrategyTests.java b/server/src/test/java/org/opensearch/rest/pagination/IndexPaginationStrategyTests.java
new file mode 100644
index 0000000000000..01464b489e26e
--- /dev/null
+++ b/server/src/test/java/org/opensearch/rest/pagination/IndexPaginationStrategyTests.java
@@ -0,0 +1,399 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.rest.pagination;
+
+import org.opensearch.OpenSearchParseException;
+import org.opensearch.Version;
+import org.opensearch.cluster.ClusterName;
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.cluster.metadata.Metadata;
+import org.opensearch.cluster.routing.IndexRoutingTable;
+import org.opensearch.cluster.routing.RoutingTable;
+import org.opensearch.test.OpenSearchTestCase;
+
+import java.time.Instant;
+import java.time.temporal.ChronoUnit;
+import java.util.ArrayList;
+import java.util.Base64;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+
+import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_CREATION_DATE;
+import static org.opensearch.rest.pagination.PageParams.PARAM_ASC_SORT_VALUE;
+import static org.opensearch.rest.pagination.PageParams.PARAM_DESC_SORT_VALUE;
+import static com.carrotsearch.randomizedtesting.RandomizedTest.getRandom;
+
+public class IndexPaginationStrategyTests extends OpenSearchTestCase {
+
+    public void testRetrieveAllIndicesWithVaryingPageSize() {
+        List<Integer> indexNumberList = new ArrayList<>();
+        final int totalIndices = 100;
+        for (int indexNumber = 1; indexNumber <= 100; indexNumber++) {
+            indexNumberList.add(indexNumber);
+        }
+        // creating a cluster state with 100 indices
+        Collections.shuffle(indexNumberList, getRandom());
+        ClusterState clusterState = getRandomClusterState(indexNumberList);
+
+        // Checking pagination response for different pageSizes, which has a mix of even and odd numbers
+        // to ensure number of indices in last page is not always equal to pageSize.
+        List<Integer> pageSizeList = List.of(1, 6, 10, 13);
+        List<String> sortOrderList = List.of(PARAM_ASC_SORT_VALUE, PARAM_DESC_SORT_VALUE);
+        for (String sortOrder : sortOrderList) {
+            for (int pageSize : pageSizeList) {
+                String requestedToken = null;
+                int totalPagesToFetch = (int) Math.ceil(totalIndices / (pageSize * 1.0));
+                int indicesRemaining = totalIndices;
+                for (int pageNumber = 1; pageNumber <= totalPagesToFetch; pageNumber++) {
+                    PageParams pageParams = new PageParams(requestedToken, sortOrder, pageSize);
+                    IndexPaginationStrategy paginationStrategy = new IndexPaginationStrategy(pageParams, clusterState);
+                    if (pageNumber < totalPagesToFetch) {
+                        assertNotNull(paginationStrategy.getResponseToken().getNextToken());
+                    } else {
+                        assertNull(paginationStrategy.getResponseToken().getNextToken());
+                    }
+                    requestedToken = paginationStrategy.getResponseToken().getNextToken();
+                    // Asserting all the indices received
+                    int responseItr = 0;
+                    if (PARAM_ASC_SORT_VALUE.equals(sortOrder)) {
+                        for (int indexNumber = (pageNumber - 1) * pageSize; indexNumber < Math.min(
+                            100,
+                            pageNumber * pageSize
+                        ); indexNumber++) {
+                            assertEquals("test-index-" + (indexNumber + 1), paginationStrategy.getRequestedEntities().get(responseItr));
+                            responseItr++;
+                        }
+                    } else {
+                        int endIndexNumberForPage = Math.max(indicesRemaining - pageSize, 0);
+                        for (; indicesRemaining > endIndexNumberForPage; indicesRemaining--) {
+                            assertEquals("test-index-" + indicesRemaining, paginationStrategy.getRequestedEntities().get(responseItr));
+                            responseItr++;
+                        }
+                    }
+                    assertEquals(responseItr, paginationStrategy.getRequestedEntities().size());
+                }
+            }
+        }
+    }
+
+    public void testRetrieveAllIndicesInAscOrderWhileIndicesGetCreatedAndDeleted() {
+        List<Integer> indexNumberList = new ArrayList<>();
+        List<Integer> deletedIndices = new ArrayList<>();
+        final int totalIndices = 100;
+        final int numIndicesToDelete = 10;
+        final int numIndicesToCreate = 5;
+        List<String> indicesFetched = new ArrayList<>();
+        for (int indexNumber = 1; indexNumber <= 100; indexNumber++) {
+            indexNumberList.add(indexNumber);
+        }
+        ClusterState clusterState = getRandomClusterState(indexNumberList);
+
+        int pageSize = 6;
+        String requestedToken = null;
+        int numPages = 0;
+        do {
+            numPages++;
+            PageParams pageParams = new PageParams(requestedToken, PARAM_ASC_SORT_VALUE, pageSize);
+            IndexPaginationStrategy paginationStrategy = new IndexPaginationStrategy(pageParams, clusterState);
+            assertNotNull(paginationStrategy);
+            assertNotNull(paginationStrategy.getResponseToken());
+            requestedToken = paginationStrategy.getResponseToken().getNextToken();
+            // randomly deleting 10 indices after 3rd call
+            if (numPages == 3) {
+                deletedIndices = indexNumberList.subList(20, indexNumberList.size());
+                Collections.shuffle(deletedIndices, getRandom());
+                for (int pos = 0; pos < numIndicesToDelete; pos++) {
+                    clusterState = deleteIndexFromClusterState(clusterState, deletedIndices.get(pos));
+                }
+            }
+            // creating 5 indices after 5th call
+            if (numPages == 5) {
+                for (int indexNumber = totalIndices + 1; indexNumber <= totalIndices + numIndicesToCreate; indexNumber++) {
+                    clusterState = addIndexToClusterState(clusterState, indexNumber);
+                }
+            }
+            if (requestedToken == null) {
+                assertEquals(paginationStrategy.getRequestedEntities().size(), 5);
+            } else {
+                assertEquals(paginationStrategy.getRequestedEntities().size(), pageSize);
+            }
+
+            indicesFetched.addAll(paginationStrategy.getRequestedEntities());
+        } while (Objects.nonNull(requestedToken));
+
+        assertEquals((int) Math.ceil((double) (totalIndices + numIndicesToCreate - numIndicesToDelete) / pageSize), numPages);
+        assertEquals(totalIndices + numIndicesToCreate - numIndicesToDelete, indicesFetched.size());
+
+        // none of the deleted index should appear in the list of fetched indices
+        for (int deletedIndexPos = 0; deletedIndexPos < numIndicesToDelete; deletedIndexPos++) {
+            assertFalse(indicesFetched.contains("test-index-" + deletedIndices.get(deletedIndexPos)));
+        }
+
+        // all the newly created indices should be present in the list of fetched indices
+        for (int indexNumber = totalIndices + 1; indexNumber <= totalIndices + numIndicesToCreate; indexNumber++) {
+            assertTrue(indicesFetched.contains("test-index-" + indexNumber));
+        }
+    }
+
+    public void testRetrieveAllIndicesInDescOrderWhileIndicesGetCreatedAndDeleted() {
+        List<Integer> indexNumberList = new ArrayList<>();
+        List<Integer> deletedIndices = new ArrayList<>();
+        final int totalIndices = 100;
+        final int numIndicesToDelete = 9;
+        final int numIndicesToCreate = 5;
+        List<String> indicesFetched = new ArrayList<>();
+        for (int indexNumber = 1; indexNumber <= 100; indexNumber++) {
+            indexNumberList.add(indexNumber);
+        }
+        ClusterState clusterState = getRandomClusterState(indexNumberList);
+
+        int pageSize = 6;
+        String requestedToken = null;
+        int numPages = 0;
+        do {
+            numPages++;
+            PageParams pageParams = new PageParams(requestedToken, PARAM_DESC_SORT_VALUE, pageSize);
+            IndexPaginationStrategy paginationStrategy = new IndexPaginationStrategy(pageParams, clusterState);
+            assertNotNull(paginationStrategy);
+            assertNotNull(paginationStrategy.getResponseToken());
+            requestedToken = paginationStrategy.getResponseToken().getNextToken();
+            // randomly deleting 10 indices after 3rd call
+            if (numPages == 3) {
+                deletedIndices = indexNumberList.subList(0, 80);
+                Collections.shuffle(deletedIndices, getRandom());
+                for (int pos = 0; pos < numIndicesToDelete; pos++) {
+                    clusterState = deleteIndexFromClusterState(clusterState, deletedIndices.get(pos));
+                }
+            }
+            // creating 5 indices after 5th call
+            if (numPages == 5) {
+                for (int indexNumber = totalIndices + 1; indexNumber <= totalIndices + numIndicesToCreate; indexNumber++) {
+                    clusterState = addIndexToClusterState(clusterState, indexNumber);
+                }
+            }
+            if (requestedToken == null) {
+                assertEquals(paginationStrategy.getRequestedEntities().size(), (totalIndices - numIndicesToDelete) % pageSize);
+            } else {
+                assertEquals(paginationStrategy.getRequestedEntities().size(), pageSize);
+            }
+
+            indicesFetched.addAll(paginationStrategy.getRequestedEntities());
+        } while (Objects.nonNull(requestedToken));
+
+        assertEquals((int) Math.ceil((double) (totalIndices - numIndicesToDelete) / pageSize), numPages);
+        assertEquals(totalIndices - numIndicesToDelete, indicesFetched.size());
+
+        // none of the deleted index should appear in the list of fetched indices
+        for (int deletedIndexPos = 0; deletedIndexPos < numIndicesToDelete; deletedIndexPos++) {
+            assertFalse(indicesFetched.contains("test-index-" + deletedIndices.get(deletedIndexPos)));
+        }
+
+        // none of the newly created indices should be present in the list of fetched indices
+        for (int indexNumber = totalIndices + 1; indexNumber <= totalIndices + numIndicesToCreate; indexNumber++) {
+            assertFalse(indicesFetched.contains("test-index-" + indexNumber));
+        }
+    }
+
+    public void testRetrieveIndicesWithSizeOneAndCurrentIndexGetsDeletedAscOrder() {
+        // Query1 with 4 indices in clusterState (test-index1,2,3,4)
+        ClusterState clusterState = getRandomClusterState(List.of(1, 2, 3, 4));
+        PageParams pageParams = new PageParams(null, PARAM_ASC_SORT_VALUE, 1);
+        IndexPaginationStrategy paginationStrategy = new IndexPaginationStrategy(pageParams, clusterState);
+        assertPaginationResult(paginationStrategy, 1, true);
+        assertEquals("test-index-1", paginationStrategy.getRequestedEntities().get(0));
+
+        // Adding index5 to clusterState, before executing next query.
+        clusterState = addIndexToClusterState(clusterState, 5);
+        pageParams = new PageParams(paginationStrategy.getResponseToken().getNextToken(), PARAM_ASC_SORT_VALUE, 1);
+        paginationStrategy = new IndexPaginationStrategy(pageParams, clusterState);
+        assertPaginationResult(paginationStrategy, 1, true);
+        assertEquals("test-index-2", paginationStrategy.getRequestedEntities().get(0));
+
+        // Deleting test-index-2 which has already been displayed, still test-index-3 should get displayed
+        clusterState = deleteIndexFromClusterState(clusterState, 2);
+        pageParams = new PageParams(paginationStrategy.getResponseToken().getNextToken(), PARAM_ASC_SORT_VALUE, 1);
+        paginationStrategy = new IndexPaginationStrategy(pageParams, clusterState);
+        assertPaginationResult(paginationStrategy, 1, true);
+        assertEquals("test-index-3", paginationStrategy.getRequestedEntities().get(0));
+
+        // Deleting test-index-4 which is not yet displayed which otherwise should have been displayed in the following query
+        // instead test-index-5 should now get displayed.
+        clusterState = deleteIndexFromClusterState(clusterState, 4);
+        pageParams = new PageParams(paginationStrategy.getResponseToken().getNextToken(), PARAM_ASC_SORT_VALUE, 1);
+        paginationStrategy = new IndexPaginationStrategy(pageParams, clusterState);
+        assertPaginationResult(paginationStrategy, 1, false);
+        assertEquals("test-index-5", paginationStrategy.getRequestedEntities().get(0));
+
+    }
+
+    public void testRetrieveIndicesWithSizeOneAndCurrentIndexGetsDeletedDescOrder() {
+        // Query1 with 4 indices in clusterState (test-index1,2,3,4).
+        ClusterState clusterState = getRandomClusterState(List.of(1, 2, 3, 4));
+        PageParams pageParams = new PageParams(null, PARAM_DESC_SORT_VALUE, 1);
+        IndexPaginationStrategy paginationStrategy = new IndexPaginationStrategy(pageParams, clusterState);
+        assertPaginationResult(paginationStrategy, 1, true);
+        assertEquals("test-index-4", paginationStrategy.getRequestedEntities().get(0));
+
+        // adding test-index-5 to clusterState, before executing next query.
+        clusterState = addIndexToClusterState(clusterState, 5);
+        pageParams = new PageParams(paginationStrategy.getResponseToken().getNextToken(), PARAM_DESC_SORT_VALUE, 1);
+        paginationStrategy = new IndexPaginationStrategy(pageParams, clusterState);
+        assertPaginationResult(paginationStrategy, 1, true);
+        assertEquals("test-index-3", paginationStrategy.getRequestedEntities().get(0));
+
+        // Deleting test-index-3 which has already been displayed, still index2 should get displayed.
+        clusterState = deleteIndexFromClusterState(clusterState, 3);
+        pageParams = new PageParams(paginationStrategy.getResponseToken().getNextToken(), PARAM_DESC_SORT_VALUE, 1);
+        paginationStrategy = new IndexPaginationStrategy(pageParams, clusterState);
+        assertPaginationResult(paginationStrategy, 1, true);
+        assertEquals("test-index-2", paginationStrategy.getRequestedEntities().get(0));
+
+        // Deleting test-index-1 which is not yet displayed which otherwise should have been displayed in the following query.
+        clusterState = deleteIndexFromClusterState(clusterState, 1);
+        pageParams = new PageParams(paginationStrategy.getResponseToken().getNextToken(), PARAM_DESC_SORT_VALUE, 1);
+        paginationStrategy = new IndexPaginationStrategy(pageParams, clusterState);
+        assertPaginationResult(paginationStrategy, 0, false);
+    }
+
+    public void testRetrieveIndicesWithMultipleDeletionsAtOnceAscOrder() {
+        // Query1 with 5 indices in clusterState (test-index1,2,3,4,5).
+        ClusterState clusterState = getRandomClusterState(List.of(1, 2, 3, 4, 5));
+        PageParams pageParams = new PageParams(null, PARAM_ASC_SORT_VALUE, 1);
+        IndexPaginationStrategy paginationStrategy = new IndexPaginationStrategy(pageParams, clusterState);
+        assertEquals(1, paginationStrategy.getRequestedEntities().size());
+        assertEquals("test-index-1", paginationStrategy.getRequestedEntities().get(0));
+        assertNotNull(paginationStrategy.getResponseToken().getNextToken());
+
+        // executing next query without any changes to clusterState
+        pageParams = new PageParams(paginationStrategy.getResponseToken().getNextToken(), PARAM_ASC_SORT_VALUE, 1);
+        paginationStrategy = new IndexPaginationStrategy(pageParams, clusterState);
+        assertEquals(1, paginationStrategy.getRequestedEntities().size());
+        assertEquals("test-index-2", paginationStrategy.getRequestedEntities().get(0));
+        assertNotNull(paginationStrategy.getResponseToken().getNextToken());
+
+        // Deleting test-index-1, test-index-2 & test-index-3 and executing next query. test-index-4 should get displayed.
+        clusterState = deleteIndexFromClusterState(clusterState, 1);
+        clusterState = deleteIndexFromClusterState(clusterState, 2);
+        clusterState = deleteIndexFromClusterState(clusterState, 3);
+        pageParams = new PageParams(paginationStrategy.getResponseToken().getNextToken(), PARAM_ASC_SORT_VALUE, 1);
+        paginationStrategy = new IndexPaginationStrategy(pageParams, clusterState);
+        assertEquals(1, paginationStrategy.getRequestedEntities().size());
+        assertEquals("test-index-4", paginationStrategy.getRequestedEntities().get(0));
+        assertNotNull(paginationStrategy.getResponseToken().getNextToken());
+
+        // Executing the last query without any further change. Should result in test-index-5 and nextToken as null.
+        pageParams = new PageParams(paginationStrategy.getResponseToken().getNextToken(), PARAM_ASC_SORT_VALUE, 1);
+        paginationStrategy = new IndexPaginationStrategy(pageParams, clusterState);
+        assertEquals(1, paginationStrategy.getRequestedEntities().size());
+        assertEquals("test-index-5", paginationStrategy.getRequestedEntities().get(0));
+        assertNull(paginationStrategy.getResponseToken().getNextToken());
+    }
+
+    public void testRetrieveIndicesWithTokenModifiedToQueryBeyondTotal() {
+        ClusterState clusterState = getRandomClusterState(List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
+        PageParams pageParams = new PageParams(null, PARAM_ASC_SORT_VALUE, 10);
+        IndexPaginationStrategy paginationStrategy = new IndexPaginationStrategy(pageParams, clusterState);
+        assertEquals(10, paginationStrategy.getRequestedEntities().size());
+        assertNull(paginationStrategy.getResponseToken().getNextToken());
+        // creating a token with last sent index as test-index-10
+        String token = clusterState.metadata().indices().get("test-index-10").getCreationDate() + "|" + "test-index-10";
+        pageParams = new PageParams(Base64.getEncoder().encodeToString(token.getBytes(UTF_8)), PARAM_ASC_SORT_VALUE, 10);
+        paginationStrategy = new IndexPaginationStrategy(pageParams, clusterState);
+        assertEquals(0, paginationStrategy.getRequestedEntities().size());
+        assertNull(paginationStrategy.getResponseToken().getNextToken());
+    }
+
+    public void testCreatingIndexStrategyPageTokenWithRequestedTokenNull() {
+        try {
+            new IndexPaginationStrategy.IndexStrategyToken(null);
+            fail("expected exception");
+        } catch (Exception e) {
+            assert e.getMessage().contains("requestedTokenString can not be null");
+        }
+    }
+
+    public void testIndexStrategyPageTokenWithWronglyEncryptedRequestToken() {
+        assertThrows(OpenSearchParseException.class, () -> new IndexPaginationStrategy.IndexStrategyToken("3%4%5"));
+    }
+
+    public void testIndexStrategyPageTokenWithIncorrectNumberOfElementsInRequestedToken() {
+        assertThrows(
+            OpenSearchParseException.class,
+            () -> new IndexPaginationStrategy.IndexStrategyToken(PaginationStrategy.encryptStringToken("1725361543"))
+        );
+        assertThrows(
+            OpenSearchParseException.class,
+            () -> new IndexPaginationStrategy.IndexStrategyToken(PaginationStrategy.encryptStringToken("1|1725361543|index|12345"))
+        );
+    }
+
+    public void testIndexStrategyPageTokenWithInvalidValuesInRequestedToken() {
+        assertThrows(
+            OpenSearchParseException.class,
+            () -> new IndexPaginationStrategy.IndexStrategyToken(PaginationStrategy.encryptStringToken("-1725361543|index"))
+        );
+    }
+
+    public void testCreatingIndexStrategyPageTokenWithNameOfLastRespondedIndexNull() {
+        try {
+            new IndexPaginationStrategy.IndexStrategyToken(1234l, null);
+            fail("expected exception");
+        } catch (Exception e) {
+            assert e.getMessage().contains("index name should be provided");
+        }
+    }
+
+    /**
+     * @param indexNumbers would be used to create indices having names with integer appended after foo, like foo1, foo2.
+     * @return random clusterState consisting of indices having their creation times set to the integer used to name them.
+     */
+    private ClusterState getRandomClusterState(List<Integer> indexNumbers) {
+        ClusterState clusterState = ClusterState.builder(new ClusterName("test"))
+            .metadata(Metadata.builder().build())
+            .routingTable(RoutingTable.builder().build())
+            .build();
+        for (Integer indexNumber : indexNumbers) {
+            clusterState = addIndexToClusterState(clusterState, indexNumber);
+        }
+        return clusterState;
+    }
+
+    private ClusterState addIndexToClusterState(ClusterState clusterState, int indexNumber) {
+        IndexMetadata indexMetadata = IndexMetadata.builder("test-index-" + indexNumber)
+            .settings(
+                settings(Version.CURRENT).put(SETTING_CREATION_DATE, Instant.now().plus(indexNumber, ChronoUnit.SECONDS).toEpochMilli())
+            )
+            .numberOfShards(between(1, 10))
+            .numberOfReplicas(randomInt(20))
+            .build();
+        IndexRoutingTable.Builder indexRoutingTableBuilder = new IndexRoutingTable.Builder(indexMetadata.getIndex());
+        return ClusterState.builder(clusterState)
+            .metadata(Metadata.builder(clusterState.metadata()).put(indexMetadata, true).build())
+            .routingTable(RoutingTable.builder(clusterState.routingTable()).add(indexRoutingTableBuilder).build())
+            .build();
+    }
+
+    private ClusterState deleteIndexFromClusterState(ClusterState clusterState, int indexNumber) {
+        return ClusterState.builder(clusterState)
+            .metadata(Metadata.builder(clusterState.metadata()).remove("test-index-" + indexNumber))
+            .routingTable(RoutingTable.builder(clusterState.routingTable()).remove("test-index-" + indexNumber).build())
+            .build();
+    }
+
+    private void assertPaginationResult(IndexPaginationStrategy paginationStrategy, int expectedEntities, boolean tokenExpected) {
+        assertNotNull(paginationStrategy);
+        assertEquals(expectedEntities, paginationStrategy.getRequestedEntities().size());
+        assertNotNull(paginationStrategy.getResponseToken());
+        assertEquals(tokenExpected, Objects.nonNull(paginationStrategy.getResponseToken().getNextToken()));
+    }
+
+}
diff --git a/server/src/test/java/org/opensearch/snapshots/SnapshotResiliencyTests.java b/server/src/test/java/org/opensearch/snapshots/SnapshotResiliencyTests.java
index 440227436175d..d17e661615b0d 100644
--- a/server/src/test/java/org/opensearch/snapshots/SnapshotResiliencyTests.java
+++ b/server/src/test/java/org/opensearch/snapshots/SnapshotResiliencyTests.java
@@ -2429,7 +2429,8 @@ public void onFailure(final Exception e) {
                             nodeEnv,
                             indicesService,
                             namedXContentRegistry
-                        )
+                        ),
+                        new ClusterManagerMetrics(NoopMetricsRegistry.INSTANCE)
                     )
                 );
                 actions.put(
diff --git a/test/fixtures/hdfs-fixture/build.gradle b/test/fixtures/hdfs-fixture/build.gradle
index 99b0386a48808..bc63362980bea 100644
--- a/test/fixtures/hdfs-fixture/build.gradle
+++ b/test/fixtures/hdfs-fixture/build.gradle
@@ -77,7 +77,7 @@ dependencies {
   api "ch.qos.logback:logback-core:1.5.8"
   api "ch.qos.logback:logback-classic:1.2.13"
   api "org.jboss.xnio:xnio-nio:3.8.16.Final"
-  api 'org.jline:jline:3.26.3'
+  api 'org.jline:jline:3.27.0'
   api 'org.apache.commons:commons-configuration2:2.11.0'
   api 'com.nimbusds:nimbus-jose-jwt:9.41.1'
   api ('org.apache.kerby:kerb-admin:2.1.0') {
diff --git a/test/framework/src/main/java/org/opensearch/cluster/MockInternalClusterInfoService.java b/test/framework/src/main/java/org/opensearch/cluster/MockInternalClusterInfoService.java
index 35ca5d80aeb4e..ded457601c0ae 100644
--- a/test/framework/src/main/java/org/opensearch/cluster/MockInternalClusterInfoService.java
+++ b/test/framework/src/main/java/org/opensearch/cluster/MockInternalClusterInfoService.java
@@ -125,7 +125,8 @@ List<NodeStats> adjustNodesStats(List<NodeStats> nodesStats) {
                 nodeStats.getSegmentReplicationRejectionStats(),
                 nodeStats.getRepositoriesStats(),
                 nodeStats.getAdmissionControlStats(),
-                nodeStats.getNodeCacheStats()
+                nodeStats.getNodeCacheStats(),
+                nodeStats.getRemoteStoreNodeStats()
             );
         }).collect(Collectors.toList());
     }
diff --git a/test/framework/src/main/java/org/opensearch/test/InternalTestCluster.java b/test/framework/src/main/java/org/opensearch/test/InternalTestCluster.java
index 7adff82e72245..fa5fb736f518f 100644
--- a/test/framework/src/main/java/org/opensearch/test/InternalTestCluster.java
+++ b/test/framework/src/main/java/org/opensearch/test/InternalTestCluster.java
@@ -2752,6 +2752,7 @@ public void ensureEstimatedStats() {
                     false,
                     false,
                     false,
+                    false,
                     false
                 );
                 assertThat(
diff --git a/test/framework/src/main/java/org/opensearch/test/OpenSearchIntegTestCase.java b/test/framework/src/main/java/org/opensearch/test/OpenSearchIntegTestCase.java
index 68a2b8086a92e..e27ff311c06f6 100644
--- a/test/framework/src/main/java/org/opensearch/test/OpenSearchIntegTestCase.java
+++ b/test/framework/src/main/java/org/opensearch/test/OpenSearchIntegTestCase.java
@@ -2795,6 +2795,26 @@ public static Settings buildRemoteStoreNodeAttributes(
         );
     }
 
+    public static Settings buildRemoteStateNodeAttributes(String stateRepoName, Path stateRepoPath, String stateRepoType) {
+        String stateRepoTypeAttributeKey = String.format(
+            Locale.getDefault(),
+            "node.attr." + REMOTE_STORE_REPOSITORY_TYPE_ATTRIBUTE_KEY_FORMAT,
+            stateRepoName
+        );
+        String stateRepoSettingsAttributeKeyPrefix = String.format(
+            Locale.getDefault(),
+            "node.attr." + REMOTE_STORE_REPOSITORY_SETTINGS_ATTRIBUTE_KEY_PREFIX,
+            stateRepoName
+        );
+        String prefixModeVerificationSuffix = BlobStoreRepository.PREFIX_MODE_VERIFICATION_SETTING.getKey();
+        Settings.Builder settings = Settings.builder()
+            .put("node.attr." + REMOTE_STORE_CLUSTER_STATE_REPOSITORY_NAME_ATTRIBUTE_KEY, stateRepoName)
+            .put(stateRepoTypeAttributeKey, stateRepoType)
+            .put(stateRepoSettingsAttributeKeyPrefix + "location", stateRepoPath)
+            .put(stateRepoSettingsAttributeKeyPrefix + prefixModeVerificationSuffix, prefixModeVerificationEnable);
+        return settings.build();
+    }
+
     private static Settings buildRemoteStoreNodeAttributes(
         String segmentRepoName,
         Path segmentRepoPath,
@@ -2850,16 +2870,6 @@ private static Settings buildRemoteStoreNodeAttributes(
             "node.attr." + REMOTE_STORE_REPOSITORY_SETTINGS_ATTRIBUTE_KEY_PREFIX,
             translogRepoName
         );
-        String stateRepoTypeAttributeKey = String.format(
-            Locale.getDefault(),
-            "node.attr." + REMOTE_STORE_REPOSITORY_TYPE_ATTRIBUTE_KEY_FORMAT,
-            segmentRepoName
-        );
-        String stateRepoSettingsAttributeKeyPrefix = String.format(
-            Locale.getDefault(),
-            "node.attr." + REMOTE_STORE_REPOSITORY_SETTINGS_ATTRIBUTE_KEY_PREFIX,
-            segmentRepoName
-        );
         String routingTableRepoAttributeKey = null, routingTableRepoSettingsAttributeKeyPrefix = null;
         if (routingTableRepoName != null) {
             routingTableRepoAttributeKey = String.format(
@@ -2885,10 +2895,7 @@ private static Settings buildRemoteStoreNodeAttributes(
             .put(translogRepoTypeAttributeKey, translogRepoType)
             .put(translogRepoSettingsAttributeKeyPrefix + "location", translogRepoPath)
             .put(translogRepoSettingsAttributeKeyPrefix + prefixModeVerificationSuffix, prefixModeVerificationEnable)
-            .put("node.attr." + REMOTE_STORE_CLUSTER_STATE_REPOSITORY_NAME_ATTRIBUTE_KEY, segmentRepoName)
-            .put(stateRepoTypeAttributeKey, segmentRepoType)
-            .put(stateRepoSettingsAttributeKeyPrefix + "location", segmentRepoPath)
-            .put(stateRepoSettingsAttributeKeyPrefix + prefixModeVerificationSuffix, prefixModeVerificationEnable);
+            .put(buildRemoteStateNodeAttributes(segmentRepoName, segmentRepoPath, segmentRepoType));
         if (routingTableRepoName != null) {
             settings.put("node.attr." + REMOTE_STORE_ROUTING_TABLE_REPOSITORY_NAME_ATTRIBUTE_KEY, routingTableRepoName)
                 .put(routingTableRepoAttributeKey, routingTableRepoType)