diff --git a/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack023_PreviewTokenTest.cs b/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack023_PreviewTokenTest.cs
new file mode 100644
index 0000000..4c90ed7
--- /dev/null
+++ b/Contentstack.Management.Core.Tests/IntegrationTest/Contentstack023_PreviewTokenTest.cs
@@ -0,0 +1,569 @@
+using System;
+using System.Collections.Generic;
+using System.Net;
+using System.Threading.Tasks;
+using Contentstack.Management.Core.Models;
+using Contentstack.Management.Core.Models.Token;
+using Contentstack.Management.Core.Tests.Helpers;
+using Contentstack.Management.Core.Tests.Model;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System.Text.Json.Nodes;
+
+namespace Contentstack.Management.Core.Tests.IntegrationTest
+{
+    /// <summary>
+    /// Integration tests for Preview Token Create and Delete APIs.
+    ///
+    /// Endpoint shape (both operations share the same path — no preview token uid):
+    ///   POST   /v3/stacks/delivery_tokens/{delivery_token_uid}/preview_token
+    ///   DELETE /v3/stacks/delivery_tokens/{delivery_token_uid}/preview_token
+    ///
+    /// Preview Tokens are compatible only with rest-preview.contentstack.com.
+    /// </summary>
+    [TestClass]
+    public class Contentstack023_PreviewTokenTest
+    {
+        private static ContentstackClient _client;
+        private Stack _stack;
+        private string _deliveryTokenUid;
+
+        private const string NonExistentTokenUid = "blt00000000000000000000";
+        private const string InvalidTokenUid = "invalid-uid-format";
+
+        [ClassInitialize]
+        public static void ClassInitialize(TestContext _)
+        {
+            _client = Contentstack.CreateAuthenticatedClient();
+        }
+
+        [ClassCleanup(ClassCleanupBehavior.EndOfClass)]
+        public static void ClassCleanup()
+        {
+            try { _client?.Logout(); } catch { }
+            _client = null;
+        }
+
+        [TestInitialize]
+        public async Task Initialize()
+        {
+            try
+            {
+                StackResponse response = StackResponse.getStack(_client.serializer);
+                _stack = _client.Stack(response.Stack.APIKey);
+                _deliveryTokenUid = null;
+
+                await EnsureDeliveryTokenExists();
+            }
+            catch (Exception ex)
+            {
+                AssertLogger.Fail($"Initialize failed: {ex.Message}");
+            }
+        }
+
+        #region Happy Path Tests
+
+        [TestMethod]
+        [DoNotParallelize]
+        public async Task Test001_Should_Create_Preview_Token()
+        {
+            TestOutputLogger.LogContext("TestScenario", "Test001_Should_Create_Preview_Token");
+            try
+            {
+                AssertLogger.IsNotNull(_deliveryTokenUid, "Delivery token must exist before creating preview token");
+
+                var model = new PreviewTokenModel
+                {
+                    Name = "Test Preview Token",
+                    Description = "Integration test preview token"
+                };
+
+                ContentstackResponse response = _stack.PreviewToken(_deliveryTokenUid).Create(model);
+
+                AssertLogger.IsTrue(response.IsSuccessStatusCode, $"Create preview token failed: {response.OpenResponse()}", "CreatePreviewTokenSuccess");
+
+                var responseObject = response.OpenJsonObjectResponse();
+                AssertLogger.IsNotNull(responseObject["notice"], "Response should contain notice");
+
+                var tokenData = responseObject["token"] as JsonObject;
+                AssertLogger.IsNotNull(tokenData, "Response should contain token object");
+
+                Console.WriteLine($"Create response: {response.OpenResponse()}");
+            }
+            catch (Exception ex)
+            {
+                AssertLogger.Fail($"Create preview token test failed: {ex.Message}");
+            }
+        }
+
+        [TestMethod]
+        [DoNotParallelize]
+        public async Task Test002_Should_Create_Preview_Token_Async()
+        {
+            TestOutputLogger.LogContext("TestScenario", "Test002_Should_Create_Preview_Token_Async");
+            try
+            {
+                AssertLogger.IsNotNull(_deliveryTokenUid, "Delivery token must exist before creating preview token");
+
+                var model = new PreviewTokenModel
+                {
+                    Name = "Async Test Preview Token",
+                    Description = "Async integration test preview token"
+                };
+
+                ContentstackResponse response = await _stack.PreviewToken(_deliveryTokenUid).CreateAsync(model);
+
+                AssertLogger.IsTrue(response.IsSuccessStatusCode, $"Async create preview token failed: {response.OpenResponse()}", "AsyncCreatePreviewTokenSuccess");
+
+                var responseObject = response.OpenJsonObjectResponse();
+                AssertLogger.IsNotNull(responseObject["notice"], "Response should contain notice");
+
+                Console.WriteLine($"Async create response: {response.OpenResponse()}");
+            }
+            catch (Exception ex)
+            {
+                AssertLogger.Fail($"Async create preview token test failed: {ex.Message}");
+            }
+        }
+
+        [TestMethod]
+        [DoNotParallelize]
+        public async Task Test003_Should_Delete_Preview_Token()
+        {
+            TestOutputLogger.LogContext("TestScenario", "Test003_Should_Delete_Preview_Token");
+            try
+            {
+                AssertLogger.IsNotNull(_deliveryTokenUid, "Delivery token must exist");
+
+                // Ensure a preview token exists first
+                await EnsurePreviewTokenExists();
+
+                ContentstackResponse response = _stack.PreviewToken(_deliveryTokenUid).Delete();
+
+                AssertLogger.IsTrue(response.IsSuccessStatusCode, $"Delete preview token failed: {response.OpenResponse()}", "DeletePreviewTokenSuccess");
+
+                var responseObject = response.OpenJsonObjectResponse();
+                AssertLogger.IsNotNull(responseObject["notice"], "Response should contain notice");
+
+                Console.WriteLine($"Delete response: {response.OpenResponse()}");
+            }
+            catch (Exception ex)
+            {
+                AssertLogger.Fail($"Delete preview token test failed: {ex.Message}");
+            }
+        }
+
+        [TestMethod]
+        [DoNotParallelize]
+        public async Task Test004_Should_Delete_Preview_Token_Async()
+        {
+            TestOutputLogger.LogContext("TestScenario", "Test004_Should_Delete_Preview_Token_Async");
+            try
+            {
+                AssertLogger.IsNotNull(_deliveryTokenUid, "Delivery token must exist");
+
+                await EnsurePreviewTokenExists();
+
+                ContentstackResponse response = await _stack.PreviewToken(_deliveryTokenUid).DeleteAsync();
+
+                AssertLogger.IsTrue(response.IsSuccessStatusCode, $"Async delete preview token failed: {response.OpenResponse()}", "AsyncDeletePreviewTokenSuccess");
+
+                Console.WriteLine($"Async delete response: {response.OpenResponse()}");
+            }
+            catch (Exception ex)
+            {
+                AssertLogger.Fail($"Async delete preview token test failed: {ex.Message}");
+            }
+        }
+
+        [TestMethod]
+        [DoNotParallelize]
+        public async Task Test005_Should_Create_And_Delete_Preview_Token_Lifecycle()
+        {
+            TestOutputLogger.LogContext("TestScenario", "Test005_Should_Create_And_Delete_Preview_Token_Lifecycle");
+            try
+            {
+                AssertLogger.IsNotNull(_deliveryTokenUid, "Delivery token must exist");
+
+                var model = new PreviewTokenModel
+                {
+                    Name = "Lifecycle Test Preview Token",
+                    Description = "Preview token for lifecycle testing"
+                };
+
+                // Create
+                ContentstackResponse createResponse = _stack.PreviewToken(_deliveryTokenUid).Create(model);
+                AssertLogger.IsTrue(createResponse.IsSuccessStatusCode, "Lifecycle create failed", "LifecycleCreate");
+
+                // Delete (same path — no preview token uid needed)
+                ContentstackResponse deleteResponse = _stack.PreviewToken(_deliveryTokenUid).Delete();
+                AssertLogger.IsTrue(deleteResponse.IsSuccessStatusCode, "Lifecycle delete failed", "LifecycleDelete");
+
+                Console.WriteLine("Successfully completed preview token lifecycle: create→delete");
+            }
+            catch (Exception ex)
+            {
+                AssertLogger.Fail($"Preview token lifecycle test failed: {ex.Message}");
+            }
+        }
+
+        [TestMethod]
+        [DoNotParallelize]
+        public async Task Test006_Should_Create_Preview_Token_With_Empty_Description()
+        {
+            TestOutputLogger.LogContext("TestScenario", "Test006_Should_Create_Preview_Token_With_Empty_Description");
+            try
+            {
+                AssertLogger.IsNotNull(_deliveryTokenUid, "Delivery token must exist");
+
+                var model = new PreviewTokenModel
+                {
+                    Name = "No Description Preview Token",
+                    Description = ""
+                };
+
+                ContentstackResponse response = _stack.PreviewToken(_deliveryTokenUid).Create(model);
+                AssertLogger.IsTrue(response.IsSuccessStatusCode, $"Create with empty description failed: {response.OpenResponse()}", "EmptyDescriptionCreate");
+            }
+            catch (Exception ex)
+            {
+                AssertLogger.Fail($"Empty description preview token test failed: {ex.Message}");
+            }
+        }
+
+        #endregion
+
+        #region A — Create Error Tests (Test020-Test029)
+
+        [TestMethod]
+        [DoNotParallelize]
+        public void Test020_Should_Fail_Create_With_Null_Model()
+        {
+            TestOutputLogger.LogContext("TestScenario", "Test020_Should_Fail_Create_With_Null_Model");
+            AssertLogger.IsNotNull(_deliveryTokenUid, "Delivery token must exist");
+            AssertLogger.ThrowsException<ArgumentNullException>(
+                () => _stack.PreviewToken(_deliveryTokenUid).Create(null),
+                "CreateWithNullModel");
+        }
+
+        [TestMethod]
+        [DoNotParallelize]
+        public void Test021_Should_Fail_Create_Async_With_Null_Model()
+        {
+            TestOutputLogger.LogContext("TestScenario", "Test021_Should_Fail_Create_Async_With_Null_Model");
+            AssertLogger.IsNotNull(_deliveryTokenUid, "Delivery token must exist");
+            AssertLogger.ThrowsException<ArgumentNullException>(
+                () => _stack.PreviewToken(_deliveryTokenUid).CreateAsync(null),
+                "CreateWithNullModelAsync");
+        }
+
+        [TestMethod]
+        [DoNotParallelize]
+        public void Test022_Should_Fail_Create_With_Nonexistent_Delivery_Token()
+        {
+            TestOutputLogger.LogContext("TestScenario", "Test022_Should_Fail_Create_With_Nonexistent_Delivery_Token");
+            var model = new PreviewTokenModel { Name = "Test", Description = "test" };
+            AssertLogger.ThrowsContentstackError(
+                () => _stack.PreviewToken(NonExistentTokenUid).Create(model),
+                "CreateWithNonexistentDeliveryToken",
+                HttpStatusCode.NotFound,
+                HttpStatusCode.BadRequest,
+                (HttpStatusCode)422);
+        }
+
+        [TestMethod]
+        [DoNotParallelize]
+        public async Task Test023_Should_Fail_Create_Async_With_Nonexistent_Delivery_Token()
+        {
+            TestOutputLogger.LogContext("TestScenario", "Test023_Should_Fail_Create_Async_With_Nonexistent_Delivery_Token");
+            var model = new PreviewTokenModel { Name = "Test", Description = "test" };
+            await AssertLogger.ThrowsContentstackErrorAsync(
+                async () => await _stack.PreviewToken(NonExistentTokenUid).CreateAsync(model),
+                "CreateWithNonexistentDeliveryTokenAsync",
+                HttpStatusCode.NotFound,
+                HttpStatusCode.BadRequest,
+                (HttpStatusCode)422);
+        }
+
+        [TestMethod]
+        [DoNotParallelize]
+        public void Test024_Should_Fail_Create_With_Invalid_Delivery_Token_Uid()
+        {
+            TestOutputLogger.LogContext("TestScenario", "Test024_Should_Fail_Create_With_Invalid_Delivery_Token_Uid");
+            var model = new PreviewTokenModel { Name = "Test", Description = "test" };
+            AssertLogger.ThrowsContentstackError(
+                () => _stack.PreviewToken(InvalidTokenUid).Create(model),
+                "CreateWithInvalidDeliveryTokenUid",
+                HttpStatusCode.BadRequest,
+                (HttpStatusCode)422,
+                HttpStatusCode.NotFound);
+        }
+
+        [TestMethod]
+        [DoNotParallelize]
+        public void Test025_Should_Accept_Create_With_Null_Name()
+        {
+            TestOutputLogger.LogContext("TestScenario", "Test025_Should_Accept_Create_With_Null_Name");
+            AssertLogger.IsNotNull(_deliveryTokenUid, "Delivery token must exist");
+            // API accepts null name — it uses the delivery token's existing name
+            var model = new PreviewTokenModel { Name = null, Description = "test" };
+            ContentstackResponse response = _stack.PreviewToken(_deliveryTokenUid).Create(model);
+            AssertLogger.IsTrue(response.IsSuccessStatusCode, "API should accept null name", "NullNameAccepted");
+        }
+
+        [TestMethod]
+        [DoNotParallelize]
+        public void Test026_Should_Accept_Create_With_Empty_Name()
+        {
+            TestOutputLogger.LogContext("TestScenario", "Test026_Should_Accept_Create_With_Empty_Name");
+            AssertLogger.IsNotNull(_deliveryTokenUid, "Delivery token must exist");
+            // API accepts empty name — it uses the delivery token's existing name
+            var model = new PreviewTokenModel { Name = "", Description = "test" };
+            ContentstackResponse response = _stack.PreviewToken(_deliveryTokenUid).Create(model);
+            AssertLogger.IsTrue(response.IsSuccessStatusCode, "API should accept empty name", "EmptyNameAccepted");
+        }
+
+        #endregion
+
+        #region B — Delete Error Tests (Test040-Test049)
+
+        [TestMethod]
+        [DoNotParallelize]
+        public void Test040_Should_Fail_Delete_With_Nonexistent_Delivery_Token()
+        {
+            TestOutputLogger.LogContext("TestScenario", "Test040_Should_Fail_Delete_With_Nonexistent_Delivery_Token");
+            AssertLogger.ThrowsContentstackError(
+                () => _stack.PreviewToken(NonExistentTokenUid).Delete(),
+                "DeleteWithNonexistentDeliveryToken",
+                HttpStatusCode.NotFound,
+                HttpStatusCode.BadRequest,
+                (HttpStatusCode)422);
+        }
+
+        [TestMethod]
+        [DoNotParallelize]
+        public async Task Test041_Should_Fail_Delete_Async_With_Nonexistent_Delivery_Token()
+        {
+            TestOutputLogger.LogContext("TestScenario", "Test041_Should_Fail_Delete_Async_With_Nonexistent_Delivery_Token");
+            await AssertLogger.ThrowsContentstackErrorAsync(
+                async () => await _stack.PreviewToken(NonExistentTokenUid).DeleteAsync(),
+                "DeleteWithNonexistentDeliveryTokenAsync",
+                HttpStatusCode.NotFound,
+                HttpStatusCode.BadRequest,
+                (HttpStatusCode)422);
+        }
+
+        [TestMethod]
+        [DoNotParallelize]
+        public void Test042_Should_Fail_Delete_With_Invalid_Delivery_Token_Uid()
+        {
+            TestOutputLogger.LogContext("TestScenario", "Test042_Should_Fail_Delete_With_Invalid_Delivery_Token_Uid");
+            AssertLogger.ThrowsContentstackError(
+                () => _stack.PreviewToken(InvalidTokenUid).Delete(),
+                "DeleteWithInvalidDeliveryTokenUid",
+                HttpStatusCode.BadRequest,
+                (HttpStatusCode)422,
+                HttpStatusCode.NotFound);
+        }
+
+        [TestMethod]
+        [DoNotParallelize]
+        public async Task Test043_Should_Fail_Delete_Without_Existing_Preview_Token()
+        {
+            TestOutputLogger.LogContext("TestScenario", "Test043_Should_Fail_Delete_Without_Existing_Preview_Token");
+            try
+            {
+                AssertLogger.IsNotNull(_deliveryTokenUid, "Delivery token must exist");
+
+                // Ensure no preview token exists by deleting if present
+                try { await _stack.PreviewToken(_deliveryTokenUid).DeleteAsync(); } catch { }
+
+                // Now try deleting again — should fail since none exists
+                AssertLogger.ThrowsContentstackError(
+                    () => _stack.PreviewToken(_deliveryTokenUid).Delete(),
+                    "DeleteWithoutExistingPreviewToken",
+                    HttpStatusCode.NotFound,
+                    HttpStatusCode.BadRequest,
+                    (HttpStatusCode)422);
+            }
+            catch (Exception ex)
+            {
+                AssertLogger.Fail($"Delete without existing preview token test failed: {ex.Message}");
+            }
+        }
+
+        #endregion
+
+        #region C — Authentication / Authorization Error Tests (Test060-Test069)
+
+        [TestMethod]
+        [DoNotParallelize]
+        public void Test060_Should_Fail_Create_With_Invalid_Stack_Context()
+        {
+            TestOutputLogger.LogContext("TestScenario", "Test060_Should_Fail_Create_With_Invalid_Stack_Context");
+            try
+            {
+                var invalidStack = _client.Stack("invalid_api_key_12345");
+                var model = new PreviewTokenModel { Name = "Test", Description = "test" };
+
+                AssertLogger.ThrowsContentstackError(
+                    () => invalidStack.PreviewToken(NonExistentTokenUid).Create(model),
+                    "CreateWithInvalidStackContext",
+                    HttpStatusCode.Unauthorized,
+                    HttpStatusCode.Forbidden,
+                    HttpStatusCode.NotFound);
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"Invalid stack context test result: {ex.Message}");
+                AssertLogger.IsTrue(true, "Authentication validation handled", "InvalidStackAuth");
+            }
+        }
+
+        [TestMethod]
+        [DoNotParallelize]
+        public void Test061_Should_Fail_Delete_With_Invalid_Stack_Context()
+        {
+            TestOutputLogger.LogContext("TestScenario", "Test061_Should_Fail_Delete_With_Invalid_Stack_Context");
+            try
+            {
+                var invalidStack = _client.Stack("invalid_api_key_12345");
+
+                AssertLogger.ThrowsContentstackError(
+                    () => invalidStack.PreviewToken(NonExistentTokenUid).Delete(),
+                    "DeleteWithInvalidStackContext",
+                    HttpStatusCode.Unauthorized,
+                    HttpStatusCode.Forbidden,
+                    HttpStatusCode.NotFound);
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"Invalid stack context delete test result: {ex.Message}");
+                AssertLogger.IsTrue(true, "Authentication validation handled", "InvalidStackAuthDelete");
+            }
+        }
+
+        #endregion
+
+        #region D — Edge Case Tests (Test080-Test089)
+
+        [TestMethod]
+        [DoNotParallelize]
+        public void Test080_Should_Validate_Error_Response_Structure()
+        {
+            TestOutputLogger.LogContext("TestScenario", "Test080_Should_Validate_Error_Response_Structure");
+            try
+            {
+                var ex = AssertLogger.ThrowsContentstackError(
+                    () => _stack.PreviewToken(NonExistentTokenUid).Delete(),
+                    "ValidateErrorResponseStructure",
+                    HttpStatusCode.NotFound,
+                    HttpStatusCode.BadRequest,
+                    (HttpStatusCode)422);
+
+                AssertLogger.IsNotNull(ex.Message, "Error should have a message");
+                AssertLogger.IsTrue(ex.StatusCode != 0, "Error should have a valid status code");
+                Console.WriteLine($"Error validation — Status: {ex.StatusCode}, Message: {ex.Message}");
+            }
+            catch (Exception ex)
+            {
+                AssertLogger.Fail($"Error response structure validation failed: {ex.Message}");
+            }
+        }
+
+        [TestMethod]
+        [DoNotParallelize]
+        public async Task Test081_Should_Handle_Concurrent_Create_Operations()
+        {
+            TestOutputLogger.LogContext("TestScenario", "Test081_Should_Handle_Concurrent_Create_Operations");
+            try
+            {
+                AssertLogger.IsNotNull(_deliveryTokenUid, "Delivery token must exist");
+
+                var tasks = new List<Task<ContentstackResponse>>();
+                var model = new PreviewTokenModel { Name = "Concurrent Preview Token", Description = "Concurrent test" };
+
+                for (int i = 0; i < 3; i++)
+                {
+                    tasks.Add(Task.Run(async () =>
+                        await _stack.PreviewToken(_deliveryTokenUid).CreateAsync(model)));
+                }
+
+                var results = await Task.WhenAll(tasks);
+
+                // At least one create should succeed; duplicates may succeed or fail gracefully
+                AssertLogger.IsTrue(true, "Concurrent create operations completed without deadlock", "ConcurrentCreate");
+                Console.WriteLine($"Concurrent results: {string.Join(", ", Array.ConvertAll(results, r => r.StatusCode.ToString()))}");
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"Concurrent create test result (acceptable): {ex.Message}");
+            }
+        }
+
+        #endregion
+
+        [TestCleanup]
+        public async Task Cleanup()
+        {
+            try
+            {
+                if (!string.IsNullOrEmpty(_deliveryTokenUid))
+                {
+                    try
+                    {
+                        await _stack.PreviewToken(_deliveryTokenUid).DeleteAsync();
+                        Console.WriteLine($"Cleaned up preview token for delivery token: {_deliveryTokenUid}");
+                    }
+                    catch
+                    {
+                        // Preview token may already be deleted — that's fine
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"Cleanup failed: {ex.Message}");
+            }
+        }
+
+        #region Helper Methods
+
+        private async Task EnsureDeliveryTokenExists()
+        {
+            try
+            {
+                ContentstackResponse queryResponse = _stack.DeliveryToken().Query().Find();
+                if (queryResponse.IsSuccessStatusCode)
+                {
+                    var tokens = queryResponse.OpenJsonObjectResponse()["tokens"] as JsonArray;
+                    if (tokens?.Count > 0)
+                    {
+                        _deliveryTokenUid = tokens[0]["uid"]?.ToString();
+                        Console.WriteLine($"Using delivery token: {_deliveryTokenUid}");
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"Error resolving delivery token: {ex.Message}");
+            }
+        }
+
+        private async Task EnsurePreviewTokenExists()
+        {
+            try
+            {
+                var model = new PreviewTokenModel { Name = "Setup Preview Token", Description = "Created for delete test" };
+                await _stack.PreviewToken(_deliveryTokenUid).CreateAsync(model);
+            }
+            catch
+            {
+                // May already exist — proceed regardless
+            }
+        }
+
+
+
+        #endregion
+    }
+}
diff --git a/Contentstack.Management.Core.Unit.Tests/Models/PreviewTokenTest.cs b/Contentstack.Management.Core.Unit.Tests/Models/PreviewTokenTest.cs
new file mode 100644
index 0000000..9b71b6d
--- /dev/null
+++ b/Contentstack.Management.Core.Unit.Tests/Models/PreviewTokenTest.cs
@@ -0,0 +1,135 @@
+using System;
+using System.Threading.Tasks;
+using AutoFixture;
+using Contentstack.Management.Core.Models;
+using Contentstack.Management.Core.Models.Token;
+using Contentstack.Management.Core.Unit.Tests.Mokes;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Contentstack.Management.Core.Unit.Tests.Models
+{
+    [TestClass]
+    public class PreviewTokenTest
+    {
+        private Stack _stack;
+        private readonly IFixture _fixture = new Fixture();
+        private ContentstackResponse _contentstackResponse;
+
+        [TestInitialize]
+        public void initialize()
+        {
+            var client = new ContentstackClient();
+            _contentstackResponse = MockResponse.CreateContentstackResponse("MockResponse.txt");
+            client.ContentstackPipeline.ReplaceHandler(new MockHttpHandler(_contentstackResponse));
+            client.contentstackOptions.Authtoken = _fixture.Create<string>();
+            _stack = new Stack(client, _fixture.Create<string>());
+        }
+
+        [TestMethod]
+        public void Initialize_PreviewToken()
+        {
+            string deliveryTokenUid = _fixture.Create<string>();
+            PreviewToken token = new PreviewToken(_stack, deliveryTokenUid);
+
+            Assert.IsNull(token.Uid);
+            Assert.AreEqual($"stacks/delivery_tokens/{deliveryTokenUid}/preview_token", token.resourcePath);
+        }
+
+        [TestMethod]
+        public void Initialize_PreviewToken_ResourcePath_Is_Singular()
+        {
+            string deliveryTokenUid = _fixture.Create<string>();
+            PreviewToken token = new PreviewToken(_stack, deliveryTokenUid);
+
+            // Endpoint is "preview_token" (singular), not "preview_tokens"
+            StringAssert.EndsWith(token.resourcePath, "/preview_token");
+        }
+
+        [TestMethod]
+        public void Should_Create_PreviewToken()
+        {
+            string deliveryTokenUid = _fixture.Create<string>();
+            ContentstackResponse response = _stack.PreviewToken(deliveryTokenUid).Create(_fixture.Create<PreviewTokenModel>());
+
+            Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse());
+            Assert.AreEqual(_contentstackResponse.OpenJsonObjectResponse().ToString(), response.OpenJsonObjectResponse().ToString());
+        }
+
+        [TestMethod]
+        public async Task Should_Create_PreviewToken_Async()
+        {
+            string deliveryTokenUid = _fixture.Create<string>();
+            ContentstackResponse response = await _stack.PreviewToken(deliveryTokenUid).CreateAsync(_fixture.Create<PreviewTokenModel>());
+
+            Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse());
+            Assert.AreEqual(_contentstackResponse.OpenJsonObjectResponse().ToString(), response.OpenJsonObjectResponse().ToString());
+        }
+
+        [TestMethod]
+        public void Should_Delete_PreviewToken()
+        {
+            string deliveryTokenUid = _fixture.Create<string>();
+            ContentstackResponse response = _stack.PreviewToken(deliveryTokenUid).Delete();
+
+            Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse());
+            Assert.AreEqual(_contentstackResponse.OpenJsonObjectResponse().ToString(), response.OpenJsonObjectResponse().ToString());
+        }
+
+        [TestMethod]
+        public async Task Should_Delete_PreviewToken_Async()
+        {
+            string deliveryTokenUid = _fixture.Create<string>();
+            ContentstackResponse response = await _stack.PreviewToken(deliveryTokenUid).DeleteAsync();
+
+            Assert.AreEqual(_contentstackResponse.OpenResponse(), response.OpenResponse());
+            Assert.AreEqual(_contentstackResponse.OpenJsonObjectResponse().ToString(), response.OpenJsonObjectResponse().ToString());
+        }
+
+        [TestMethod]
+        public void Should_Throw_On_Create_With_Null_Model()
+        {
+            string deliveryTokenUid = _fixture.Create<string>();
+            Assert.ThrowsException<ArgumentNullException>(() => _stack.PreviewToken(deliveryTokenUid).Create(null));
+        }
+
+        [TestMethod]
+        public async Task Should_Throw_On_CreateAsync_With_Null_Model()
+        {
+            string deliveryTokenUid = _fixture.Create<string>();
+            await Assert.ThrowsExceptionAsync<ArgumentNullException>(() => _stack.PreviewToken(deliveryTokenUid).CreateAsync(null));
+        }
+
+        [TestMethod]
+        public void Should_Use_Stack_PreviewToken_Factory_Method()
+        {
+            string deliveryTokenUid = _fixture.Create<string>();
+            PreviewToken token = _stack.PreviewToken(deliveryTokenUid);
+
+            Assert.IsNotNull(token);
+            Assert.IsNull(token.Uid);
+            Assert.AreEqual($"stacks/delivery_tokens/{deliveryTokenUid}/preview_token", token.resourcePath);
+        }
+
+        [TestMethod]
+        public void Delete_Does_Not_Require_Uid()
+        {
+            // Delete uses the delivery token uid in the path only — no preview token uid needed.
+            string deliveryTokenUid = _fixture.Create<string>();
+            PreviewToken token = new PreviewToken(_stack, deliveryTokenUid);
+
+            // Should NOT throw ArgumentException (unlike BaseModel.Delete which needs uid)
+            ContentstackResponse response = token.Delete();
+            Assert.IsNotNull(response);
+        }
+
+        [TestMethod]
+        public async Task DeleteAsync_Does_Not_Require_Uid()
+        {
+            string deliveryTokenUid = _fixture.Create<string>();
+            PreviewToken token = new PreviewToken(_stack, deliveryTokenUid);
+
+            ContentstackResponse response = await token.DeleteAsync();
+            Assert.IsNotNull(response);
+        }
+    }
+}
diff --git a/Contentstack.Management.Core/Models/Stack.cs b/Contentstack.Management.Core/Models/Stack.cs
index ade5aea..745ac5e 100644
--- a/Contentstack.Management.Core/Models/Stack.cs
+++ b/Contentstack.Management.Core/Models/Stack.cs
@@ -806,6 +806,32 @@ public ManagementToken ManagementTokens(string? uid = null)
             return new ManagementToken(this, uid);
         }
 
+        /// <summary>
+        /// Preview Tokens provide access to retrieve website details within the Live Preview panel.
+        /// They are scoped to a specific Delivery Token and are compatible only with the rest-preview.contentstack.com endpoint.
+        /// Both Create and Delete operate on the same endpoint — no separate preview token uid is required.
+        /// </summary>
+        /// <param name="deliveryTokenUid">The UID of the Delivery Token this Preview Token is associated with.</param>
+        /// <example>
+        /// <pre><code>
+        /// ContentstackClient client = new ContentstackClient("<AUTHTOKEN>", "<API_HOST>");
+        /// Stack stack = client.Stack("<API_KEY>");
+        /// // Create a preview token
+        /// PreviewTokenModel model = new PreviewTokenModel() { Name = "My Preview Token" };
+        /// ContentstackResponse createResponse = stack.PreviewToken("<DELIVERY_TOKEN_UID>").Create(model);
+        /// // Delete the preview token
+        /// ContentstackResponse deleteResponse = stack.PreviewToken("<DELIVERY_TOKEN_UID>").Delete();
+        /// </code></pre>
+        /// </example>
+        /// <returns>The <see cref="Models.Token.PreviewToken" /></returns>
+        public PreviewToken PreviewToken(string deliveryTokenUid)
+        {
+            ThrowIfNotLoggedIn();
+            ThrowIfAPIKeyEmpty();
+
+            return new PreviewToken(this, deliveryTokenUid);
+        }
+
         /// <summary>
         /// A <see cref="Models.Role" /> collection of permissions that will be applicable to all the users who are assigned this role.
         /// </summary>
diff --git a/Contentstack.Management.Core/Models/Token/PreviewToken.cs b/Contentstack.Management.Core/Models/Token/PreviewToken.cs
new file mode 100644
index 0000000..c9fc36a
--- /dev/null
+++ b/Contentstack.Management.Core/Models/Token/PreviewToken.cs
@@ -0,0 +1,94 @@
+using System.Threading.Tasks;
+using Contentstack.Management.Core.Queryable;
+using Contentstack.Management.Core.Services.Models;
+
+namespace Contentstack.Management.Core.Models.Token
+{
+    /// <summary>
+    /// Preview Tokens provide access to retrieve website details within the Live Preview panel.
+    /// They are compatible only with the rest-preview.contentstack.com endpoint
+    /// and are scoped to a specific Delivery Token.
+    /// </summary>
+    public class PreviewToken : BaseModel<PreviewTokenModel>
+    {
+        internal PreviewToken(Stack stack, string deliveryTokenUid)
+            : base(stack, "token")
+        {
+            resourcePath = $"stacks/delivery_tokens/{deliveryTokenUid}/preview_token";
+        }
+
+        /// <summary>
+        /// Creates a Preview Token for a specific Delivery Token in a stack.
+        /// Preview Tokens are compatible only with the rest-preview.contentstack.com endpoint.
+        /// </summary>
+        /// <example>
+        /// <pre><code>
+        /// ContentstackClient client = new ContentstackClient("&lt;AUTHTOKEN&gt;", "&lt;API_HOST&gt;");
+        /// PreviewTokenModel model = new PreviewTokenModel() { Name = "My Preview Token" };
+        /// ContentstackResponse response = client.Stack("&lt;API_KEY&gt;").PreviewToken("&lt;DELIVERY_TOKEN_UID&gt;").Create(model);
+        /// </code></pre>
+        /// </example>
+        /// <param name="model">PreviewTokenModel containing the details for the new preview token.</param>
+        /// <param name="collection">Optional query parameters.</param>
+        /// <returns>The <see cref="ContentstackResponse"/>.</returns>
+        public override ContentstackResponse Create(PreviewTokenModel model, ParameterCollection? collection = null)
+        {
+            return base.Create(model, collection);
+        }
+
+        /// <summary>
+        /// Creates a Preview Token for a specific Delivery Token in a stack asynchronously.
+        /// Preview Tokens are compatible only with the rest-preview.contentstack.com endpoint.
+        /// </summary>
+        /// <example>
+        /// <pre><code>
+        /// ContentstackClient client = new ContentstackClient("&lt;AUTHTOKEN&gt;", "&lt;API_HOST&gt;");
+        /// PreviewTokenModel model = new PreviewTokenModel() { Name = "My Preview Token" };
+        /// ContentstackResponse response = await client.Stack("&lt;API_KEY&gt;").PreviewToken("&lt;DELIVERY_TOKEN_UID&gt;").CreateAsync(model);
+        /// </code></pre>
+        /// </example>
+        /// <param name="model">PreviewTokenModel containing the details for the new preview token.</param>
+        /// <param name="collection">Optional query parameters.</param>
+        /// <returns>The Task.</returns>
+        public override Task<ContentstackResponse> CreateAsync(PreviewTokenModel model, ParameterCollection? collection = null)
+        {
+            return base.CreateAsync(model, collection);
+        }
+
+        /// <summary>
+        /// Deletes the Preview Token associated with a specific Delivery Token.
+        /// </summary>
+        /// <example>
+        /// <pre><code>
+        /// ContentstackClient client = new ContentstackClient("&lt;AUTHTOKEN&gt;", "&lt;API_HOST&gt;");
+        /// ContentstackResponse response = client.Stack("&lt;API_KEY&gt;").PreviewToken("&lt;DELIVERY_TOKEN_UID&gt;").Delete();
+        /// </code></pre>
+        /// </example>
+        /// <param name="collection">Optional query parameters.</param>
+        /// <returns>The <see cref="ContentstackResponse"/>.</returns>
+        public override ContentstackResponse Delete(ParameterCollection? collection = null)
+        {
+            stack.ThrowIfNotLoggedIn();
+            var service = new FetchDeleteService(stack, resourcePath, "DELETE", collection: collection, stjOptions: stack.client.SerializerOptions);
+            return stack.client.InvokeSync(service);
+        }
+
+        /// <summary>
+        /// Deletes the Preview Token associated with a specific Delivery Token asynchronously.
+        /// </summary>
+        /// <example>
+        /// <pre><code>
+        /// ContentstackClient client = new ContentstackClient("&lt;AUTHTOKEN&gt;", "&lt;API_HOST&gt;");
+        /// ContentstackResponse response = await client.Stack("&lt;API_KEY&gt;").PreviewToken("&lt;DELIVERY_TOKEN_UID&gt;").DeleteAsync();
+        /// </code></pre>
+        /// </example>
+        /// <param name="collection">Optional query parameters.</param>
+        /// <returns>The Task.</returns>
+        public override Task<ContentstackResponse> DeleteAsync(ParameterCollection? collection = null)
+        {
+            stack.ThrowIfNotLoggedIn();
+            var service = new FetchDeleteService(stack, resourcePath, "DELETE", collection: collection, stjOptions: stack.client.SerializerOptions);
+            return stack.client.InvokeAsync<FetchDeleteService, ContentstackResponse>(service);
+        }
+    }
+}
diff --git a/Contentstack.Management.Core/Models/Token/PreviewTokenModel.cs b/Contentstack.Management.Core/Models/Token/PreviewTokenModel.cs
new file mode 100644
index 0000000..1e1e496
--- /dev/null
+++ b/Contentstack.Management.Core/Models/Token/PreviewTokenModel.cs
@@ -0,0 +1,24 @@
+using System.Text.Json.Serialization;
+
+namespace Contentstack.Management.Core.Models.Token
+{
+    /// <summary>
+    /// Model for creating a Preview Token.
+    /// Preview Tokens provide access to retrieve website details within the Live Preview panel
+    /// and are compatible only with the rest-preview.contentstack.com endpoint.
+    /// </summary>
+    public class PreviewTokenModel
+    {
+        /// <summary>
+        /// The name of the preview token.
+        /// </summary>
+        [JsonPropertyName("name")]
+        public string? Name { get; set; }
+
+        /// <summary>
+        /// The description of the preview token.
+        /// </summary>
+        [JsonPropertyName("description")]
+        public string? Description { get; set; }
+    }
+}