diff --git a/sdk/communication/Azure.Communication.Common/tests/CommunicationRecordedTestSanitizer.cs b/sdk/communication/Azure.Communication.Common/tests/CommunicationRecordedTestSanitizer.cs
index 7e2af51b54a9..ce198fde6bfe 100644
--- a/sdk/communication/Azure.Communication.Common/tests/CommunicationRecordedTestSanitizer.cs
+++ b/sdk/communication/Azure.Communication.Common/tests/CommunicationRecordedTestSanitizer.cs
@@ -12,6 +12,7 @@ public class CommunicationRecordedTestSanitizer : RecordedTestSanitizer
     {
         private static readonly Regex _azureResourceRegEx = new Regex(@"[^/]+?(?=(.communication.azure))", RegexOptions.Compiled);
         private static readonly Regex _identityInRouteRegEx = new Regex(@"(?<=identities/)([^/]+)", RegexOptions.Compiled);
+        private static readonly Regex _turnInRouteRegEx = new Regex(@"(?<=turn/)([^/]+)", RegexOptions.Compiled);
         private static readonly Regex _phoneNumberRegEx = new Regex(@"[\\+]?[0-9]{11,15}", RegexOptions.Compiled);
         private static readonly Regex _guidRegEx = new Regex(@"(\{){0,1}[0-9a-fA-F]{8}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{12}(\}){0,1}", RegexOptions.Compiled);
 
@@ -28,6 +29,9 @@ public CommunicationRecordedTestSanitizer() : base()
             JsonPathSanitizers.Add("$..phonePlanId");
             JsonPathSanitizers.Add("$..phonePlanGroupId");
             JsonPathSanitizers.Add("$..phonePlanIds[:]");
+            JsonPathSanitizers.Add("$..urls");
+            JsonPathSanitizers.Add("$..username");
+            JsonPathSanitizers.Add("$..credential");
         }
 
         public override void SanitizeHeaders(IDictionary<string, string[]> headers)
@@ -76,6 +80,7 @@ internal static string SanitizeConnectionString(string connectionString)
         public override string SanitizeUri(string uri)
         {
             uri = SanitizeAzureResource(_identityInRouteRegEx.Replace(uri, SanitizeValue.ToLower()));
+            uri = SanitizeAzureResource(_turnInRouteRegEx.Replace(uri, SanitizeValue.ToLower()));
             return _guidRegEx.Replace(uri, SanitizeValue);
         }
     }
diff --git a/sdk/communication/Azure.Communication.Identity/api/Azure.Communication.Identity.netstandard2.0.cs b/sdk/communication/Azure.Communication.Identity/api/Azure.Communication.Identity.netstandard2.0.cs
index 5b93834db90a..f1141d3c659e 100644
--- a/sdk/communication/Azure.Communication.Identity/api/Azure.Communication.Identity.netstandard2.0.cs
+++ b/sdk/communication/Azure.Communication.Identity/api/Azure.Communication.Identity.netstandard2.0.cs
@@ -15,6 +15,8 @@ public CommunicationIdentityClient(System.Uri endpoint, Azure.Core.TokenCredenti
         public virtual System.Threading.Tasks.Task<Azure.Response> DeleteUserAsync(Azure.Communication.CommunicationUserIdentifier communicationUser, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
         public virtual Azure.Response<Azure.Core.AccessToken> IssueToken(Azure.Communication.CommunicationUserIdentifier communicationUser, System.Collections.Generic.IEnumerable<Azure.Communication.Identity.CommunicationTokenScope> scopes, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
         public virtual System.Threading.Tasks.Task<Azure.Response<Azure.Core.AccessToken>> IssueTokenAsync(Azure.Communication.CommunicationUserIdentifier communicationUser, System.Collections.Generic.IEnumerable<Azure.Communication.Identity.CommunicationTokenScope> scopes, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
+        public virtual Azure.Response<Azure.Communication.Identity.Models.CommunicationTurnCredentialsResponse> IssueTurnCredentials(Azure.Communication.CommunicationUserIdentifier communicationUser, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
+        public virtual System.Threading.Tasks.Task<Azure.Response<Azure.Communication.Identity.Models.CommunicationTurnCredentialsResponse>> IssueTurnCredentialsAsync(Azure.Communication.CommunicationUserIdentifier communicationUser, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
         public virtual Azure.Response RevokeTokens(Azure.Communication.CommunicationUserIdentifier communicationUser, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
         public virtual System.Threading.Tasks.Task<Azure.Response> RevokeTokensAsync(Azure.Communication.CommunicationUserIdentifier communicationUser, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
     }
@@ -45,3 +47,19 @@ public enum ServiceVersion
         public override string ToString() { throw null; }
     }
 }
+namespace Azure.Communication.Identity.Models
+{
+    public partial class CommunicationTurnCredentialsResponse
+    {
+        internal CommunicationTurnCredentialsResponse() { }
+        public System.DateTimeOffset ExpiresOn { get { throw null; } }
+        public System.Collections.Generic.IReadOnlyList<Azure.Communication.Identity.Models.CommunicationTurnServer> TurnServers { get { throw null; } }
+    }
+    public partial class CommunicationTurnServer
+    {
+        internal CommunicationTurnServer() { }
+        public string Credential { get { throw null; } }
+        public string Urls { get { throw null; } }
+        public string Username { get { throw null; } }
+    }
+}
diff --git a/sdk/communication/Azure.Communication.Identity/samples/README.md b/sdk/communication/Azure.Communication.Identity/samples/README.md
index 74f6f18f5faa..e5d14c9a3ecf 100644
--- a/sdk/communication/Azure.Communication.Identity/samples/README.md
+++ b/sdk/communication/Azure.Communication.Identity/samples/README.md
@@ -16,12 +16,11 @@ To get started you will need to have an Azure Subscription. Once you have this y
 
 This client library allows to do following operations:
  - Generate user tokens that allows the holders to access Azure Communication Services.
- - Purchase, configure and release phone numbers.
+ - Generate TURN server credentials that allows the holders to get access to a TURN server for media relay.
 
  #### You can find samples for each of these functions below.
- - Generate user tokens [synchronously][sample_identity] or [asynchronously][sample_identity_async]
+ - Generate user tokens and TURN credentials [synchronously][sample_identity] or [asynchronously][sample_identity_async]
  
 <!-- LINKS -->
 [sample_identity]: https://github.com/Azure/azure-sdk-for-net/tree/master/sdk/communication/Azure.Communication.Identity/samples/Sample1_CommunicationIdentityClient.md
 [sample_identity_async]: https://github.com/Azure/azure-sdk-for-net/tree/master/sdk/communication/Azure.Communication.Identity/samples/Sample1_CommunicationIdentityClientAsync.md
-[
diff --git a/sdk/communication/Azure.Communication.Identity/samples/Sample1_CommunicationIdentityClient.md b/sdk/communication/Azure.Communication.Identity/samples/Sample1_CommunicationIdentityClient.md
index bcec26c194a9..3b92a4f8971e 100644
--- a/sdk/communication/Azure.Communication.Identity/samples/Sample1_CommunicationIdentityClient.md
+++ b/sdk/communication/Azure.Communication.Identity/samples/Sample1_CommunicationIdentityClient.md
@@ -55,6 +55,26 @@ Console.WriteLine($"Token: {token}");
 Console.WriteLine($"Expires On: {expiresOn}");
 ```
 
+## Generate TURN credentials
+
+The example code snippet below shows how to generate TURN credentials for an Azure Communication user that was created following the steps above.
+A set of TURN credentials are returned for the user. Each TURN credential consists of a url for a TURN server, its corresponding username and a credential. 
+
+Every set of TURN credentials is stamped with an expiry date. Once the credentials are expired, you can renew the token by calling the same method.
+
+```C# Snippet:CreateTURNTokenAsync
+Response<CommunicationTurnCredentialsResponse> turnTokenResponse = await client.IssueTurnCredentialsAsync(user);
+DateTimeOffset turnTokenExpiresOn = turnTokenResponse.Value.ExpiresOn;
+IReadOnlyList<CommunicationTurnServer> turnServers = turnTokenResponse.Value.TurnServers;
+Console.WriteLine($"Expires On: {turnTokenExpiresOn}");
+foreach (CommunicationTurnServer turnServer in turnServers)
+{
+    Console.WriteLine($"TURN Url: {turnServer.Urls}");
+    Console.WriteLine($"TURN Username: {turnServer.Username}");
+    Console.WriteLine($"TURN Credential: {turnServer.Credential}");
+}
+```
+
 <!--
 To see the full example source files, see:
 * [Generate user token][GenerateUserTokenCode]
diff --git a/sdk/communication/Azure.Communication.Identity/samples/Sample1_CommunicationIdentityClientAsync.md b/sdk/communication/Azure.Communication.Identity/samples/Sample1_CommunicationIdentityClientAsync.md
index 27d51ed212fb..e6c6b12e622d 100644
--- a/sdk/communication/Azure.Communication.Identity/samples/Sample1_CommunicationIdentityClientAsync.md
+++ b/sdk/communication/Azure.Communication.Identity/samples/Sample1_CommunicationIdentityClientAsync.md
@@ -57,6 +57,26 @@ Console.WriteLine($"Token: {token}");
 Console.WriteLine($"Expires On: {expiresOn}");
 ```
 
+## Generate TURN credentials
+
+The example code snippet below shows how to generate TURN credentials for an Azure Communication user that was created following the steps above.
+A set of TURN credentials are returned for the user. Each TURN credential consists of a url for a TURN server, its corresponding username and a credential. 
+
+Every set of TURN credentials is stamped with an expiry date. Once the credentials are expired, you can renew the token by calling the same method.
+
+```C# Snippet:CreateTURNTokenAsync
+Response<CommunicationTurnCredentialsResponse> turnTokenResponse = await client.IssueTurnCredentialsAsync(user);
+DateTimeOffset turnTokenExpiresOn = turnTokenResponse.Value.ExpiresOn;
+IReadOnlyList<CommunicationTurnServer> turnServers = turnTokenResponse.Value.TurnServers;
+Console.WriteLine($"Expires On: {turnTokenExpiresOn}");
+foreach (CommunicationTurnServer turnServer in turnServers)
+{
+    Console.WriteLine($"TURN Url: {turnServer.Urls}");
+    Console.WriteLine($"TURN Username: {turnServer.Username}");
+    Console.WriteLine($"TURN Credential: {turnServer.Credential}");
+}
+```
+
 <!--
 To see the full example source files, see:
 * [Generate user token][GenerateUserTokenCode]
diff --git a/sdk/communication/Azure.Communication.Identity/src/CommunicationIdentityClient.cs b/sdk/communication/Azure.Communication.Identity/src/CommunicationIdentityClient.cs
index e3d1667ac106..6f86c520a413 100644
--- a/sdk/communication/Azure.Communication.Identity/src/CommunicationIdentityClient.cs
+++ b/sdk/communication/Azure.Communication.Identity/src/CommunicationIdentityClient.cs
@@ -18,7 +18,10 @@ namespace Azure.Communication.Identity
     public class CommunicationIdentityClient
     {
         private readonly ClientDiagnostics _clientDiagnostics;
+        private readonly HttpPipeline _pipeline;
+        private readonly string _endpoint;
         internal CommunicationIdentityRestClient RestClient { get; }
+        internal CommunicationIdentityRestClient RestClientForTurn { get; }
 
         /// <summary> Initializes a new instance of <see cref="CommunicationIdentityClient"/>.</summary>
         /// <param name="endpoint">The URI of the Azure Communication Services resource.</param>
@@ -62,28 +65,37 @@ public CommunicationIdentityClient(Uri endpoint, TokenCredential tokenCredential
         private CommunicationIdentityClient(CommunicationIdentityClientOptions options, ConnectionString connectionString)
         {
             _clientDiagnostics = new ClientDiagnostics(options);
+            _pipeline = options.BuildHttpPipeline(connectionString);
+            _endpoint = connectionString.GetRequired("endpoint");
             RestClient = new CommunicationIdentityRestClient(
                 _clientDiagnostics,
-                options.BuildHttpPipeline(connectionString),
-                connectionString.GetRequired("endpoint"));
+                _pipeline,
+                _endpoint,
+                apiVersion: "2021-03-07");
         }
 
         private CommunicationIdentityClient(Uri endpoint, CommunicationIdentityClientOptions options, AzureKeyCredential credential)
         {
             _clientDiagnostics = new ClientDiagnostics(options);
+            _pipeline = options.BuildHttpPipeline(credential);
+            _endpoint = endpoint.AbsoluteUri;
             RestClient = new CommunicationIdentityRestClient(
                 _clientDiagnostics,
-                options.BuildHttpPipeline(credential),
-                endpoint.AbsoluteUri);
+                _pipeline,
+                _endpoint,
+                apiVersion: "2021-03-07");
         }
 
         private CommunicationIdentityClient(Uri endpoint, CommunicationIdentityClientOptions options, TokenCredential tokenCredential)
         {
             _clientDiagnostics = new ClientDiagnostics(options);
+            _pipeline = options.BuildHttpPipeline(tokenCredential);
+            _endpoint = endpoint.AbsoluteUri;
             RestClient = new CommunicationIdentityRestClient(
                 _clientDiagnostics,
-                options.BuildHttpPipeline(tokenCredential),
-                endpoint.AbsoluteUri);
+                _pipeline,
+                _endpoint,
+                apiVersion: "2021-03-07");
         }
 
         /// <summary>Initializes a new instance of <see cref="CommunicationIdentityClient"/> for mocking.</summary>
@@ -290,6 +302,57 @@ public virtual async Task<Response> RevokeTokensAsync(CommunicationUserIdentifie
             }
         }
 
+        /// <summary>Issues a token for a <see cref="CommunicationUserIdentifier"/>.</summary>
+        /// <param name="communicationUser">The <see cref="CommunicationUserIdentifier"/> for whom to issue a token.</param>
+        /// <param name="cancellationToken">The cancellation token to use.</param>
+        /// <exception cref="RequestFailedException">The server returned an error.</exception>
+        public virtual Response<CommunicationTurnCredentialsResponse> IssueTurnCredentials(CommunicationUserIdentifier communicationUser, CancellationToken cancellationToken = default)
+        {
+            var RestClientForTurn = new CommunicationIdentityRestClient(
+                _clientDiagnostics,
+                _pipeline,
+                _endpoint,
+                apiVersion: "2021-12-12");
+
+            using DiagnosticScope scope = _clientDiagnostics.CreateScope($"{nameof(CommunicationIdentityClient)}.{nameof(IssueTurnCredentials)}");
+            scope.Start();
+            try
+            {
+                Response<CommunicationTurnCredentialsResponse> response = RestClientForTurn.IssueTurnCredentials(communicationUser.Id, cancellationToken);
+                return response;
+            }
+            catch (Exception ex)
+            {
+                scope.Failed(ex);
+                throw;
+            }
+        }
+
+        /// <summary>Asynchronously issues a token for a <see cref="CommunicationUserIdentifier"/>.</summary>
+        /// <param name="communicationUser">The <see cref="CommunicationUserIdentifier"/> for whom to issue a token.</param>
+        /// <param name="cancellationToken">The cancellation token to use.</param>
+        public virtual async Task<Response<CommunicationTurnCredentialsResponse>> IssueTurnCredentialsAsync(CommunicationUserIdentifier communicationUser, CancellationToken cancellationToken = default)
+        {
+            var RestClientForTurn = new CommunicationIdentityRestClient(
+                _clientDiagnostics,
+                _pipeline,
+                _endpoint,
+                apiVersion: "2021-12-12");
+
+            using DiagnosticScope scope = _clientDiagnostics.CreateScope($"{nameof(CommunicationIdentityClient)}.{nameof(IssueTurnCredentials)}");
+            scope.Start();
+            try
+            {
+                Response<CommunicationTurnCredentialsResponse> response = await RestClientForTurn.IssueTurnCredentialsAsync(communicationUser.Id, cancellationToken).ConfigureAwait(false);
+                return response;
+            }
+            catch (Exception ex)
+            {
+                scope.Failed(ex);
+                throw;
+            }
+        }
+
         private static T AssertNotNull<T>(T argument, string argumentName)
             where T : class
         {
diff --git a/sdk/communication/Azure.Communication.Identity/src/Generated/CommunicationIdentityRestClient.cs b/sdk/communication/Azure.Communication.Identity/src/Generated/CommunicationIdentityRestClient.cs
index e8db84566e2f..84e54faf1692 100644
--- a/sdk/communication/Azure.Communication.Identity/src/Generated/CommunicationIdentityRestClient.cs
+++ b/sdk/communication/Azure.Communication.Identity/src/Generated/CommunicationIdentityRestClient.cs
@@ -30,7 +30,7 @@ internal partial class CommunicationIdentityRestClient
         /// <param name="endpoint"> The communication resource, for example https://my-resource.communication.azure.com. </param>
         /// <param name="apiVersion"> Api Version. </param>
         /// <exception cref="ArgumentNullException"> <paramref name="endpoint"/> or <paramref name="apiVersion"/> is null. </exception>
-        public CommunicationIdentityRestClient(ClientDiagnostics clientDiagnostics, HttpPipeline pipeline, string endpoint, string apiVersion = "2021-03-07")
+        public CommunicationIdentityRestClient(ClientDiagnostics clientDiagnostics, HttpPipeline pipeline, string endpoint, string apiVersion = "2021-02-22-preview1")
         {
             if (endpoint == null)
             {
@@ -316,5 +316,75 @@ public Response<CommunicationIdentityAccessToken> IssueAccessToken(string id, IE
                     throw _clientDiagnostics.CreateRequestFailedException(message.Response);
             }
         }
+
+        internal HttpMessage CreateIssueTurnCredentialsRequest(string id)
+        {
+            var message = _pipeline.CreateMessage();
+            var request = message.Request;
+            request.Method = RequestMethod.Post;
+            var uri = new RawRequestUriBuilder();
+            uri.AppendRaw(endpoint, false);
+            uri.AppendPath("/turn/", false);
+            uri.AppendPath(id, true);
+            uri.AppendPath("/:issueCredentials", false);
+            uri.AppendQuery("api-version", apiVersion, true);
+            request.Uri = uri;
+            request.Headers.Add("Accept", "application/json");
+            return message;
+        }
+
+        /// <summary> Issue TURN credentials for an existing identity. </summary>
+        /// <param name="id"> Identifier of the existing identity to issue credentials for. </param>
+        /// <param name="cancellationToken"> The cancellation token to use. </param>
+        /// <exception cref="ArgumentNullException"> <paramref name="id"/> is null. </exception>
+        public async Task<Response<CommunicationTurnCredentialsResponse>> IssueTurnCredentialsAsync(string id, CancellationToken cancellationToken = default)
+        {
+            if (id == null)
+            {
+                throw new ArgumentNullException(nameof(id));
+            }
+
+            using var message = CreateIssueTurnCredentialsRequest(id);
+            await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
+            switch (message.Response.Status)
+            {
+                case 200:
+                    {
+                        CommunicationTurnCredentialsResponse value = default;
+                        using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, cancellationToken).ConfigureAwait(false);
+                        value = CommunicationTurnCredentialsResponse.DeserializeCommunicationTurnCredentialsResponse(document.RootElement);
+                        return Response.FromValue(value, message.Response);
+                    }
+                default:
+                    throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(false);
+            }
+        }
+
+        /// <summary> Issue TURN credentials for an existing identity. </summary>
+        /// <param name="id"> Identifier of the existing identity to issue credentials for. </param>
+        /// <param name="cancellationToken"> The cancellation token to use. </param>
+        /// <exception cref="ArgumentNullException"> <paramref name="id"/> is null. </exception>
+        public Response<CommunicationTurnCredentialsResponse> IssueTurnCredentials(string id, CancellationToken cancellationToken = default)
+        {
+            if (id == null)
+            {
+                throw new ArgumentNullException(nameof(id));
+            }
+
+            using var message = CreateIssueTurnCredentialsRequest(id);
+            _pipeline.Send(message, cancellationToken);
+            switch (message.Response.Status)
+            {
+                case 200:
+                    {
+                        CommunicationTurnCredentialsResponse value = default;
+                        using var document = JsonDocument.Parse(message.Response.ContentStream);
+                        value = CommunicationTurnCredentialsResponse.DeserializeCommunicationTurnCredentialsResponse(document.RootElement);
+                        return Response.FromValue(value, message.Response);
+                    }
+                default:
+                    throw _clientDiagnostics.CreateRequestFailedException(message.Response);
+            }
+        }
     }
 }
diff --git a/sdk/communication/Azure.Communication.Identity/src/Generated/Models/CommunicationError.Serialization.cs b/sdk/communication/Azure.Communication.Identity/src/Generated/Models/CommunicationError.Serialization.cs
index 27e7e08b6515..5c97a4f25724 100644
--- a/sdk/communication/Azure.Communication.Identity/src/Generated/Models/CommunicationError.Serialization.cs
+++ b/sdk/communication/Azure.Communication.Identity/src/Generated/Models/CommunicationError.Serialization.cs
@@ -19,7 +19,7 @@ internal static CommunicationError DeserializeCommunicationError(JsonElement ele
             string message = default;
             Optional<string> target = default;
             Optional<IReadOnlyList<CommunicationError>> details = default;
-            Optional<CommunicationError> innerError = default;
+            Optional<CommunicationError> innererror = default;
             foreach (var property in element.EnumerateObject())
             {
                 if (property.NameEquals("code"))
@@ -52,18 +52,18 @@ internal static CommunicationError DeserializeCommunicationError(JsonElement ele
                     details = array;
                     continue;
                 }
-                if (property.NameEquals("innerError"))
+                if (property.NameEquals("innererror"))
                 {
                     if (property.Value.ValueKind == JsonValueKind.Null)
                     {
                         property.ThrowNonNullablePropertyIsNull();
                         continue;
                     }
-                    innerError = DeserializeCommunicationError(property.Value);
+                    innererror = DeserializeCommunicationError(property.Value);
                     continue;
                 }
             }
-            return new CommunicationError(code, message, target.Value, Optional.ToList(details), innerError.Value);
+            return new CommunicationError(code, message, target.Value, Optional.ToList(details), innererror.Value);
         }
     }
 }
diff --git a/sdk/communication/Azure.Communication.Identity/src/Generated/Models/CommunicationError.cs b/sdk/communication/Azure.Communication.Identity/src/Generated/Models/CommunicationError.cs
index e00be6938c06..c0b23da10572 100644
--- a/sdk/communication/Azure.Communication.Identity/src/Generated/Models/CommunicationError.cs
+++ b/sdk/communication/Azure.Communication.Identity/src/Generated/Models/CommunicationError.cs
@@ -39,7 +39,7 @@ internal CommunicationError(string code, string message)
         /// <param name="message"> The error message. </param>
         /// <param name="target"> The error target. </param>
         /// <param name="details"> Further details about specific errors that led to this error. </param>
-        /// <param name="innerError"> The Communication Services error. </param>
+        /// <param name="innerError"> The inner error if any. </param>
         internal CommunicationError(string code, string message, string target, IReadOnlyList<CommunicationError> details, CommunicationError innerError)
         {
             Code = code;
@@ -57,7 +57,7 @@ internal CommunicationError(string code, string message, string target, IReadOnl
         public string Target { get; }
         /// <summary> Further details about specific errors that led to this error. </summary>
         public IReadOnlyList<CommunicationError> Details { get; }
-        /// <summary> The Communication Services error. </summary>
+        /// <summary> The inner error if any. </summary>
         public CommunicationError InnerError { get; }
     }
 }
diff --git a/sdk/communication/Azure.Communication.Identity/src/Generated/Models/CommunicationTurnCredentialsResponse.Serialization.cs b/sdk/communication/Azure.Communication.Identity/src/Generated/Models/CommunicationTurnCredentialsResponse.Serialization.cs
new file mode 100644
index 000000000000..4d10b6dc9f35
--- /dev/null
+++ b/sdk/communication/Azure.Communication.Identity/src/Generated/Models/CommunicationTurnCredentialsResponse.Serialization.cs
@@ -0,0 +1,42 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+// <auto-generated/>
+
+#nullable disable
+
+using System;
+using System.Collections.Generic;
+using System.Text.Json;
+using Azure.Core;
+
+namespace Azure.Communication.Identity.Models
+{
+    public partial class CommunicationTurnCredentialsResponse
+    {
+        internal static CommunicationTurnCredentialsResponse DeserializeCommunicationTurnCredentialsResponse(JsonElement element)
+        {
+            DateTimeOffset expiresOn = default;
+            IReadOnlyList<CommunicationTurnServer> turnServers = default;
+            foreach (var property in element.EnumerateObject())
+            {
+                if (property.NameEquals("expiresOn"))
+                {
+                    expiresOn = property.Value.GetDateTimeOffset("O");
+                    continue;
+                }
+                if (property.NameEquals("turnServers"))
+                {
+                    List<CommunicationTurnServer> array = new List<CommunicationTurnServer>();
+                    foreach (var item in property.Value.EnumerateArray())
+                    {
+                        array.Add(CommunicationTurnServer.DeserializeCommunicationTurnServer(item));
+                    }
+                    turnServers = array;
+                    continue;
+                }
+            }
+            return new CommunicationTurnCredentialsResponse(expiresOn, turnServers);
+        }
+    }
+}
diff --git a/sdk/communication/Azure.Communication.Identity/src/Generated/Models/CommunicationTurnCredentialsResponse.cs b/sdk/communication/Azure.Communication.Identity/src/Generated/Models/CommunicationTurnCredentialsResponse.cs
new file mode 100644
index 000000000000..02d826f94524
--- /dev/null
+++ b/sdk/communication/Azure.Communication.Identity/src/Generated/Models/CommunicationTurnCredentialsResponse.cs
@@ -0,0 +1,46 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+// <auto-generated/>
+
+#nullable disable
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Azure.Communication.Identity.Models
+{
+    /// <summary> A TURN credentials response. </summary>
+    public partial class CommunicationTurnCredentialsResponse
+    {
+        /// <summary> Initializes a new instance of CommunicationTurnCredentialsResponse. </summary>
+        /// <param name="expiresOn"> The date for which the username and credentials are not longer valid. </param>
+        /// <param name="turnServers"> An array representing the credentials and the TURN server URL. </param>
+        /// <exception cref="ArgumentNullException"> <paramref name="turnServers"/> is null. </exception>
+        internal CommunicationTurnCredentialsResponse(DateTimeOffset expiresOn, IEnumerable<CommunicationTurnServer> turnServers)
+        {
+            if (turnServers == null)
+            {
+                throw new ArgumentNullException(nameof(turnServers));
+            }
+
+            ExpiresOn = expiresOn;
+            TurnServers = turnServers.ToList();
+        }
+
+        /// <summary> Initializes a new instance of CommunicationTurnCredentialsResponse. </summary>
+        /// <param name="expiresOn"> The date for which the username and credentials are not longer valid. </param>
+        /// <param name="turnServers"> An array representing the credentials and the TURN server URL. </param>
+        internal CommunicationTurnCredentialsResponse(DateTimeOffset expiresOn, IReadOnlyList<CommunicationTurnServer> turnServers)
+        {
+            ExpiresOn = expiresOn;
+            TurnServers = turnServers;
+        }
+
+        /// <summary> The date for which the username and credentials are not longer valid. </summary>
+        public DateTimeOffset ExpiresOn { get; }
+        /// <summary> An array representing the credentials and the TURN server URL. </summary>
+        public IReadOnlyList<CommunicationTurnServer> TurnServers { get; }
+    }
+}
diff --git a/sdk/communication/Azure.Communication.Identity/src/Generated/Models/CommunicationTurnServer.Serialization.cs b/sdk/communication/Azure.Communication.Identity/src/Generated/Models/CommunicationTurnServer.Serialization.cs
new file mode 100644
index 000000000000..11ce3e6f159e
--- /dev/null
+++ b/sdk/communication/Azure.Communication.Identity/src/Generated/Models/CommunicationTurnServer.Serialization.cs
@@ -0,0 +1,41 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+// <auto-generated/>
+
+#nullable disable
+
+using System.Text.Json;
+using Azure.Core;
+
+namespace Azure.Communication.Identity.Models
+{
+    public partial class CommunicationTurnServer
+    {
+        internal static CommunicationTurnServer DeserializeCommunicationTurnServer(JsonElement element)
+        {
+            string urls = default;
+            string username = default;
+            string credential = default;
+            foreach (var property in element.EnumerateObject())
+            {
+                if (property.NameEquals("urls"))
+                {
+                    urls = property.Value.GetString();
+                    continue;
+                }
+                if (property.NameEquals("username"))
+                {
+                    username = property.Value.GetString();
+                    continue;
+                }
+                if (property.NameEquals("credential"))
+                {
+                    credential = property.Value.GetString();
+                    continue;
+                }
+            }
+            return new CommunicationTurnServer(urls, username, credential);
+        }
+    }
+}
diff --git a/sdk/communication/Azure.Communication.Identity/src/Generated/Models/CommunicationTurnServer.cs b/sdk/communication/Azure.Communication.Identity/src/Generated/Models/CommunicationTurnServer.cs
new file mode 100644
index 000000000000..674b51ce933f
--- /dev/null
+++ b/sdk/communication/Azure.Communication.Identity/src/Generated/Models/CommunicationTurnServer.cs
@@ -0,0 +1,47 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+// <auto-generated/>
+
+#nullable disable
+
+using System;
+
+namespace Azure.Communication.Identity.Models
+{
+    /// <summary> An instance of a TURN server with credentials. </summary>
+    public partial class CommunicationTurnServer
+    {
+        /// <summary> Initializes a new instance of CommunicationTurnServer. </summary>
+        /// <param name="urls"> URL of the server. </param>
+        /// <param name="username"> User account name which uniquely identifies the credentials. </param>
+        /// <param name="credential"> Credential for the server. </param>
+        /// <exception cref="ArgumentNullException"> <paramref name="urls"/>, <paramref name="username"/>, or <paramref name="credential"/> is null. </exception>
+        internal CommunicationTurnServer(string urls, string username, string credential)
+        {
+            if (urls == null)
+            {
+                throw new ArgumentNullException(nameof(urls));
+            }
+            if (username == null)
+            {
+                throw new ArgumentNullException(nameof(username));
+            }
+            if (credential == null)
+            {
+                throw new ArgumentNullException(nameof(credential));
+            }
+
+            Urls = urls;
+            Username = username;
+            Credential = credential;
+        }
+
+        /// <summary> URL of the server. </summary>
+        public string Urls { get; }
+        /// <summary> User account name which uniquely identifies the credentials. </summary>
+        public string Username { get; }
+        /// <summary> Credential for the server. </summary>
+        public string Credential { get; }
+    }
+}
diff --git a/sdk/communication/Azure.Communication.Identity/src/autorest.md b/sdk/communication/Azure.Communication.Identity/src/autorest.md
index c9fa62846115..00669dde0f1d 100644
--- a/sdk/communication/Azure.Communication.Identity/src/autorest.md
+++ b/sdk/communication/Azure.Communication.Identity/src/autorest.md
@@ -7,6 +7,7 @@ Run `dotnet msbuild /t:GenerateCode` to generate code.
 
 ``` yaml
 input-file:
-    -  https://raw.githubusercontent.com/Azure/azure-rest-api-specs/5b19c6e69cd2bb9dbe4e5c1237b2c5a175d90ca5/specification/communication/data-plane/Microsoft.CommunicationServicesIdentity/stable/2021-03-07/CommunicationIdentity.json
+    - https://raw.githubusercontent.com/Azure/azure-rest-api-specs/a1eee0489c374782a934ec1f093abd16fa7718ca/specification/communication/data-plane/Microsoft.CommunicationServicesIdentity/preview/2021-02-22-preview1/CommunicationIdentity.json
+    - https://raw.githubusercontent.com/Azure/azure-rest-api-specs/a1eee0489c374782a934ec1f093abd16fa7718ca/specification/communication/data-plane/Microsoft.CommunicationServicesTurn/preview/2021-02-22-preview1/CommunicationTurn.json
 payload-flattening-threshold: 3
 ```
diff --git a/sdk/communication/Azure.Communication.Identity/tests/CommunicationIdentityClient/CommunicationIdentityClientLiveTests.cs b/sdk/communication/Azure.Communication.Identity/tests/CommunicationIdentityClient/CommunicationIdentityClientLiveTests.cs
index def9cd9c96ae..8ee2f59348ec 100644
--- a/sdk/communication/Azure.Communication.Identity/tests/CommunicationIdentityClient/CommunicationIdentityClientLiveTests.cs
+++ b/sdk/communication/Azure.Communication.Identity/tests/CommunicationIdentityClient/CommunicationIdentityClientLiveTests.cs
@@ -4,6 +4,7 @@
 using System;
 using System.Linq;
 using System.Threading.Tasks;
+using Azure.Communication.Identity.Models;
 using Azure.Core;
 using Azure.Core.TestFramework;
 using Azure.Identity;
@@ -61,6 +62,32 @@ void ValidateScopesIfNotSanitized()
             }
         }
 
+        [Test]
+        [TestCase(AuthMethod.ConnectionString, TestName = "IssuingTurnCredentialsWithConnectionString")]
+        [TestCase(AuthMethod.KeyCredential, TestName = "IssuingTurnCredentialsWithKeyCredential")]
+        public async Task IssuingTurnCredentialsGeneratesTurnCredentials(AuthMethod authMethod)
+        {
+            CommunicationIdentityClient client = authMethod switch
+            {
+                AuthMethod.ConnectionString => CreateClientWithConnectionString(),
+                AuthMethod.KeyCredential => CreateClientWithAzureKeyCredential(),
+                _ => throw new ArgumentOutOfRangeException(nameof(authMethod)),
+            };
+
+            Response<CommunicationUserIdentifier> userResponse = await client.CreateUserAsync();
+            Response<CommunicationTurnCredentialsResponse> turnCredentialsResponse = await client.IssueTurnCredentialsAsync(userResponse.Value);
+
+            Assert.IsNotNull(turnCredentialsResponse.Value);
+            Assert.IsNotNull(turnCredentialsResponse.Value.ExpiresOn);
+            Assert.IsNotNull(turnCredentialsResponse.Value.TurnServers);
+            foreach (CommunicationTurnServer serverCredential in turnCredentialsResponse.Value.TurnServers)
+            {
+                Assert.IsFalse(string.IsNullOrWhiteSpace(serverCredential.Urls));
+                Assert.IsFalse(string.IsNullOrWhiteSpace(serverCredential.Username));
+                Assert.IsFalse(string.IsNullOrWhiteSpace(serverCredential.Credential));
+            }
+        }
+
         public enum AuthMethod
         {
             ConnectionString,
diff --git a/sdk/communication/Azure.Communication.Identity/tests/SessionRecords/CommunicationIdentityClientLiveTests/IssuingTurnCredentialsWithConnectionString.json b/sdk/communication/Azure.Communication.Identity/tests/SessionRecords/CommunicationIdentityClientLiveTests/IssuingTurnCredentialsWithConnectionString.json
new file mode 100644
index 000000000000..52625ea95a93
--- /dev/null
+++ b/sdk/communication/Azure.Communication.Identity/tests/SessionRecords/CommunicationIdentityClientLiveTests/IssuingTurnCredentialsWithConnectionString.json
@@ -0,0 +1,87 @@
+{
+  "Entries": [
+    {
+      "RequestUri": "https://sanitized.communication.azure.com/identities?api-version=2021-03-07",
+      "RequestMethod": "POST",
+      "RequestHeaders": {
+        "Accept": "application/json",
+        "Authorization": "Sanitized",
+        "Content-Length": "2",
+        "Content-Type": "application/json",
+        "Date": "Thu, 18 Feb 2021 01:29:02 GMT",
+        "traceparent": "00-3984a6ea4a0d684ca32ee868dc0ec077-72f1db1bc05ab24b-00",
+        "User-Agent": [
+          "azsdk-net-Communication.Identity/1.0.0-alpha.20210217.1",
+          "(.NET Core 4.6.29321.03; Microsoft Windows 10.0.21313 )"
+        ],
+        "x-ms-client-request-id": "5cacd6c9bae859d65910f49a5e79fd2a",
+        "x-ms-content-sha256": "Sanitized",
+        "x-ms-return-client-request-id": "true"
+      },
+      "RequestBody": {},
+      "StatusCode": 201,
+      "ResponseHeaders": {
+        "api-supported-versions": "2020-07-20-preview2, 2021-03-07",
+        "Content-Type": "application/json; charset=utf-8",
+        "Date": "Thu, 18 Feb 2021 01:29:01 GMT",
+        "MS-CV": "jb9esvQ6rUe5AK0DzGwf0w.0",
+        "Request-Context": "appId=",
+        "Strict-Transport-Security": "max-age=2592000",
+        "Transfer-Encoding": "chunked",
+        "X-Azure-Ref": "03sItYAAAAADnItHAOOAoTIq48\u002BhltfmHV1NURURHRTA4MTAAOWZjN2I1MTktYThjYy00Zjg5LTkzNWUtYzkxNDhhZTA5ZTgx",
+        "x-ms-client-request-id": "5cacd6c9bae859d65910f49a5e79fd2a",
+        "X-Processing-Time": "10ms"
+      },
+      "ResponseBody": {
+        "identity": {
+          "id": "Sanitized"
+        }
+      }
+    },
+    {
+      "RequestUri": "https://sanitized.communication.azure.com/turn/sanitized/:issueCredentials?api-version=2021-12-12",
+      "RequestMethod": "POST",
+      "RequestHeaders": {
+        "Accept": "application/json",
+        "Authorization": "Sanitized",
+        "Date": "Thu, 18 Feb 2021 01:29:02 GMT",
+        "traceparent": "00-62a1870457ab1a48917a70673ecf6b04-328b1be358e9174b-00",
+        "User-Agent": [
+          "azsdk-net-Communication.Identity/1.0.0-alpha.20210217.1",
+          "(.NET Core 4.6.29321.03; Microsoft Windows 10.0.21313 )"
+        ],
+        "x-ms-client-request-id": "b021ce6fbb22a10ab7e4671429227dfb",
+        "x-ms-content-sha256": "Sanitized",
+        "x-ms-return-client-request-id": "true"
+      },
+      "RequestBody": null,
+      "StatusCode": 200,
+      "ResponseHeaders": {
+        "api-supported-versions": "2021-12-12",
+        "Content-Type": "application/json; charset=utf-8",
+        "Date": "Thu, 18 Feb 2021 01:29:01 GMT",
+        "MS-CV": "CwB3jGCW8UKMGvRkqhyh\u002BA.0",
+        "Request-Context": "appId=",
+        "Strict-Transport-Security": "max-age=2592000",
+        "Transfer-Encoding": "chunked",
+        "X-Azure-Ref": "03sItYAAAAAAT58SILtb1Soaj2sUByTAJV1NURURHRTA4MTAAOWZjN2I1MTktYThjYy00Zjg5LTkzNWUtYzkxNDhhZTA5ZTgx",
+        "x-ms-client-request-id": "b021ce6fbb22a10ab7e4671429227dfb",
+        "X-Processing-Time": "54ms"
+      },
+      "ResponseBody": {
+        "expiresOn": "2021-02-18T01:29:02.154162\u002B00:00",
+        "turnServers": [
+          {
+            "urls": "Sanitized",
+            "username": "Sanitized",
+            "credential": "Sanitized"
+          }
+        ]
+      }
+    }
+  ],
+  "Variables": {
+    "COMMUNICATION_CONNECTION_STRING": "endpoint=https://sanitized.communication.azure.com/;accesskey=Kg==",
+    "RandomSeed": "2119321244"
+  }
+}
\ No newline at end of file
diff --git a/sdk/communication/Azure.Communication.Identity/tests/SessionRecords/CommunicationIdentityClientLiveTests/IssuingTurnCredentialsWithConnectionStringAsync.json b/sdk/communication/Azure.Communication.Identity/tests/SessionRecords/CommunicationIdentityClientLiveTests/IssuingTurnCredentialsWithConnectionStringAsync.json
new file mode 100644
index 000000000000..8715fe34d14c
--- /dev/null
+++ b/sdk/communication/Azure.Communication.Identity/tests/SessionRecords/CommunicationIdentityClientLiveTests/IssuingTurnCredentialsWithConnectionStringAsync.json
@@ -0,0 +1,87 @@
+{
+  "Entries": [
+    {
+      "RequestUri": "https://sanitized.communication.azure.com/identities?api-version=2021-03-07",
+      "RequestMethod": "POST",
+      "RequestHeaders": {
+        "Accept": "application/json",
+        "Authorization": "Sanitized",
+        "Content-Length": "2",
+        "Content-Type": "application/json",
+        "Date": "Thu, 18 Feb 2021 01:29:03 GMT",
+        "traceparent": "00-ebb3bb2684daee45b4ce161b79ebbda6-e764ebe79038654c-00",
+        "User-Agent": [
+          "azsdk-net-Communication.Identity/1.0.0-alpha.20210217.1",
+          "(.NET Core 4.6.29321.03; Microsoft Windows 10.0.21313 )"
+        ],
+        "x-ms-client-request-id": "d08a7f42d0939c197c010cfd89c93f18",
+        "x-ms-content-sha256": "Sanitized",
+        "x-ms-return-client-request-id": "true"
+      },
+      "RequestBody": {},
+      "StatusCode": 201,
+      "ResponseHeaders": {
+        "api-supported-versions": "2020-07-20-preview2, 2021-03-07",
+        "Content-Type": "application/json; charset=utf-8",
+        "Date": "Thu, 18 Feb 2021 01:29:02 GMT",
+        "MS-CV": "jcz3yT/2KEuP\u002BWIBS0zhaQ.0",
+        "Request-Context": "appId=",
+        "Strict-Transport-Security": "max-age=2592000",
+        "Transfer-Encoding": "chunked",
+        "X-Azure-Ref": "038ItYAAAAAAl8zU5j406Tq9M9oe9cfAqV1NURURHRTA4MTAAOWZjN2I1MTktYThjYy00Zjg5LTkzNWUtYzkxNDhhZTA5ZTgx",
+        "x-ms-client-request-id": "d08a7f42d0939c197c010cfd89c93f18",
+        "X-Processing-Time": "11ms"
+      },
+      "ResponseBody": {
+        "identity": {
+          "id": "Sanitized"
+        }
+      }
+    },
+    {
+      "RequestUri": "https://sanitized.communication.azure.com/turn/sanitized/:issueCredentials?api-version=2021-12-12",
+      "RequestMethod": "POST",
+      "RequestHeaders": {
+        "Accept": "application/json",
+        "Authorization": "Sanitized",
+        "Date": "Thu, 18 Feb 2021 01:29:03 GMT",
+        "traceparent": "00-218edf1872163c42bc943be3f7121f6d-687a4b9c80c7314d-00",
+        "User-Agent": [
+          "azsdk-net-Communication.Identity/1.0.0-alpha.20210217.1",
+          "(.NET Core 4.6.29321.03; Microsoft Windows 10.0.21313 )"
+        ],
+        "x-ms-client-request-id": "dd0477c740f01d6c586ec18db040d832",
+        "x-ms-content-sha256": "Sanitized",
+        "x-ms-return-client-request-id": "true"
+      },
+      "RequestBody": null,
+      "StatusCode": 200,
+      "ResponseHeaders": {
+        "api-supported-versions": "2021-12-12",
+        "Content-Type": "application/json; charset=utf-8",
+        "Date": "Thu, 18 Feb 2021 01:29:02 GMT",
+        "MS-CV": "filgmE9elkmcN4S9zwURyQ.0",
+        "Request-Context": "appId=",
+        "Strict-Transport-Security": "max-age=2592000",
+        "Transfer-Encoding": "chunked",
+        "X-Azure-Ref": "038ItYAAAAADj7AFbmz64RJ0t\u002Bw1HAUt8V1NURURHRTA4MTAAOWZjN2I1MTktYThjYy00Zjg5LTkzNWUtYzkxNDhhZTA5ZTgx",
+        "x-ms-client-request-id": "dd0477c740f01d6c586ec18db040d832",
+        "X-Processing-Time": "54ms"
+      },
+      "ResponseBody": {
+        "expiresOn": "2021-02-18T01:29:03.2297364\u002B00:00",
+        "turnServers": [
+          {
+            "urls": "Sanitized",
+            "username": "Sanitized",
+            "credential": "Sanitized"
+          }
+        ]
+      }
+    }
+  ],
+  "Variables": {
+    "COMMUNICATION_CONNECTION_STRING": "endpoint=https://sanitized.communication.azure.com/;accesskey=Kg==",
+    "RandomSeed": "593635836"
+  }
+}
\ No newline at end of file
diff --git a/sdk/communication/Azure.Communication.Identity/tests/SessionRecords/CommunicationIdentityClientLiveTests/IssuingTurnCredentialsWithKeyCredential.json b/sdk/communication/Azure.Communication.Identity/tests/SessionRecords/CommunicationIdentityClientLiveTests/IssuingTurnCredentialsWithKeyCredential.json
new file mode 100644
index 000000000000..fa3dd83d9c56
--- /dev/null
+++ b/sdk/communication/Azure.Communication.Identity/tests/SessionRecords/CommunicationIdentityClientLiveTests/IssuingTurnCredentialsWithKeyCredential.json
@@ -0,0 +1,88 @@
+{
+  "Entries": [
+    {
+      "RequestUri": "https://sanitized.communication.azure.com/identities?api-version=2021-03-07",
+      "RequestMethod": "POST",
+      "RequestHeaders": {
+        "Accept": "application/json",
+        "Authorization": "Sanitized",
+        "Content-Length": "2",
+        "Content-Type": "application/json",
+        "Date": "Thu, 18 Feb 2021 01:29:02 GMT",
+        "traceparent": "00-af7dea797bbcb54ebfffa0ff214cef8d-d9c21371493e7546-00",
+        "User-Agent": [
+          "azsdk-net-Communication.Identity/1.0.0-alpha.20210217.1",
+          "(.NET Core 4.6.29321.03; Microsoft Windows 10.0.21313 )"
+        ],
+        "x-ms-client-request-id": "5dbe685fbefd78063a1314f3cb65c44b",
+        "x-ms-content-sha256": "Sanitized",
+        "x-ms-return-client-request-id": "true"
+      },
+      "RequestBody": {},
+      "StatusCode": 201,
+      "ResponseHeaders": {
+        "api-supported-versions": "2020-07-20-preview2, 2021-03-07",
+        "Content-Type": "application/json; charset=utf-8",
+        "Date": "Thu, 18 Feb 2021 01:29:01 GMT",
+        "MS-CV": "as5u3TkoR0O4Fy5b5y/K0w.0",
+        "Request-Context": "appId=",
+        "Strict-Transport-Security": "max-age=2592000",
+        "Transfer-Encoding": "chunked",
+        "X-Azure-Ref": "03sItYAAAAABDAcCJwzBVSILxKq/c1eOWV1NURURHRTA4MTAAOWZjN2I1MTktYThjYy00Zjg5LTkzNWUtYzkxNDhhZTA5ZTgx",
+        "x-ms-client-request-id": "5dbe685fbefd78063a1314f3cb65c44b",
+        "X-Processing-Time": "11ms"
+      },
+      "ResponseBody": {
+        "identity": {
+          "id": "Sanitized"
+        }
+      }
+    },
+    {
+      "RequestUri": "https://sanitized.communication.azure.com/turn/sanitized/:issueCredentials?api-version=2021-12-12",
+      "RequestMethod": "POST",
+      "RequestHeaders": {
+        "Accept": "application/json",
+        "Authorization": "Sanitized",
+        "Date": "Thu, 18 Feb 2021 01:29:02 GMT",
+        "traceparent": "00-b4d726f610177841b2bcc5a7e02704e8-424c12b4431aa343-00",
+        "User-Agent": [
+          "azsdk-net-Communication.Identity/1.0.0-alpha.20210217.1",
+          "(.NET Core 4.6.29321.03; Microsoft Windows 10.0.21313 )"
+        ],
+        "x-ms-client-request-id": "be5d24da77e0941ffe21ecb01af62dc7",
+        "x-ms-content-sha256": "Sanitized",
+        "x-ms-return-client-request-id": "true"
+      },
+      "RequestBody": null,
+      "StatusCode": 200,
+      "ResponseHeaders": {
+        "api-supported-versions": "2021-12-12",
+        "Content-Type": "application/json; charset=utf-8",
+        "Date": "Thu, 18 Feb 2021 01:29:01 GMT",
+        "MS-CV": "QYIWr67TA02bOfIoY7lZfg.0",
+        "Request-Context": "appId=",
+        "Strict-Transport-Security": "max-age=2592000",
+        "Transfer-Encoding": "chunked",
+        "X-Azure-Ref": "03sItYAAAAAAc70ZU44\u002BURoGqNqD6at0UV1NURURHRTA4MTAAOWZjN2I1MTktYThjYy00Zjg5LTkzNWUtYzkxNDhhZTA5ZTgx",
+        "x-ms-client-request-id": "be5d24da77e0941ffe21ecb01af62dc7",
+        "X-Processing-Time": "52ms"
+      },
+      "ResponseBody": {
+        "expiresOn": "2021-02-18T01:29:02.3118663\u002B00:00",
+        "turnServers": [
+          {
+            "urls": "Sanitized",
+            "username": "Sanitized",
+            "credential": "Sanitized"
+          }
+        ]
+      }
+    }
+  ],
+  "Variables": {
+    "COMMUNICATION_ACCESS_KEY": "Kg==",
+    "COMMUNICATION_ENDPOINT": "https://sanitized.communication.azure.com",
+    "RandomSeed": "1767078601"
+  }
+}
\ No newline at end of file
diff --git a/sdk/communication/Azure.Communication.Identity/tests/SessionRecords/CommunicationIdentityClientLiveTests/IssuingTurnCredentialsWithKeyCredentialAsync.json b/sdk/communication/Azure.Communication.Identity/tests/SessionRecords/CommunicationIdentityClientLiveTests/IssuingTurnCredentialsWithKeyCredentialAsync.json
new file mode 100644
index 000000000000..607205234e4f
--- /dev/null
+++ b/sdk/communication/Azure.Communication.Identity/tests/SessionRecords/CommunicationIdentityClientLiveTests/IssuingTurnCredentialsWithKeyCredentialAsync.json
@@ -0,0 +1,88 @@
+{
+  "Entries": [
+    {
+      "RequestUri": "https://sanitized.communication.azure.com/identities?api-version=2021-03-07",
+      "RequestMethod": "POST",
+      "RequestHeaders": {
+        "Accept": "application/json",
+        "Authorization": "Sanitized",
+        "Content-Length": "2",
+        "Content-Type": "application/json",
+        "Date": "Thu, 18 Feb 2021 01:29:03 GMT",
+        "traceparent": "00-7de7bb0741579c47a136d3ad0e135033-88ea959360f7b642-00",
+        "User-Agent": [
+          "azsdk-net-Communication.Identity/1.0.0-alpha.20210217.1",
+          "(.NET Core 4.6.29321.03; Microsoft Windows 10.0.21313 )"
+        ],
+        "x-ms-client-request-id": "c589cc7a8aafae86e8c2866078bf6e65",
+        "x-ms-content-sha256": "Sanitized",
+        "x-ms-return-client-request-id": "true"
+      },
+      "RequestBody": {},
+      "StatusCode": 201,
+      "ResponseHeaders": {
+        "api-supported-versions": "2020-07-20-preview2, 2021-03-07",
+        "Content-Type": "application/json; charset=utf-8",
+        "Date": "Thu, 18 Feb 2021 01:29:02 GMT",
+        "MS-CV": "Xb7CSnIf50iS5gJgP1NMag.0",
+        "Request-Context": "appId=",
+        "Strict-Transport-Security": "max-age=2592000",
+        "Transfer-Encoding": "chunked",
+        "X-Azure-Ref": "038ItYAAAAABLs35rObMFQ5k2v9vRLIugV1NURURHRTA4MTAAOWZjN2I1MTktYThjYy00Zjg5LTkzNWUtYzkxNDhhZTA5ZTgx",
+        "x-ms-client-request-id": "c589cc7a8aafae86e8c2866078bf6e65",
+        "X-Processing-Time": "11ms"
+      },
+      "ResponseBody": {
+        "identity": {
+          "id": "Sanitized"
+        }
+      }
+    },
+    {
+      "RequestUri": "https://sanitized.communication.azure.com/turn/sanitized/:issueCredentials?api-version=2021-12-12",
+      "RequestMethod": "POST",
+      "RequestHeaders": {
+        "Accept": "application/json",
+        "Authorization": "Sanitized",
+        "Date": "Thu, 18 Feb 2021 01:29:03 GMT",
+        "traceparent": "00-d74b6a15a86ef34c87d32ee8b46162ec-51fb9bc7d107cd4c-00",
+        "User-Agent": [
+          "azsdk-net-Communication.Identity/1.0.0-alpha.20210217.1",
+          "(.NET Core 4.6.29321.03; Microsoft Windows 10.0.21313 )"
+        ],
+        "x-ms-client-request-id": "d64cc3d21a27d34b79c91acb13f887e0",
+        "x-ms-content-sha256": "Sanitized",
+        "x-ms-return-client-request-id": "true"
+      },
+      "RequestBody": null,
+      "StatusCode": 200,
+      "ResponseHeaders": {
+        "api-supported-versions": "2021-12-12",
+        "Content-Type": "application/json; charset=utf-8",
+        "Date": "Thu, 18 Feb 2021 01:29:02 GMT",
+        "MS-CV": "WXXgp1Dq7kqyuPzW4GsFqw.0",
+        "Request-Context": "appId=",
+        "Strict-Transport-Security": "max-age=2592000",
+        "Transfer-Encoding": "chunked",
+        "X-Azure-Ref": "038ItYAAAAADehe3CODQiTJH84aOFKZbeV1NURURHRTA4MTAAOWZjN2I1MTktYThjYy00Zjg5LTkzNWUtYzkxNDhhZTA5ZTgx",
+        "x-ms-client-request-id": "d64cc3d21a27d34b79c91acb13f887e0",
+        "X-Processing-Time": "56ms"
+      },
+      "ResponseBody": {
+        "expiresOn": "2021-02-18T01:29:03.3875856\u002B00:00",
+        "turnServers": [
+          {
+            "urls": "Sanitized",
+            "username": "Sanitized",
+            "credential": "Sanitized"
+          }
+        ]
+      }
+    }
+  ],
+  "Variables": {
+    "COMMUNICATION_ACCESS_KEY": "Kg==",
+    "COMMUNICATION_ENDPOINT": "https://sanitized.communication.azure.com",
+    "RandomSeed": "549191420"
+  }
+}
\ No newline at end of file
diff --git a/sdk/communication/Azure.Communication.Identity/tests/SessionRecords/Sample1_CommunicationIdentityClient/UserAndTokenLifeCycle.json b/sdk/communication/Azure.Communication.Identity/tests/SessionRecords/Sample1_CommunicationIdentityClient/UserAndTokenLifeCycle.json
index 88c6449f4f2d..3bcaf193a4f1 100644
--- a/sdk/communication/Azure.Communication.Identity/tests/SessionRecords/Sample1_CommunicationIdentityClient/UserAndTokenLifeCycle.json
+++ b/sdk/communication/Azure.Communication.Identity/tests/SessionRecords/Sample1_CommunicationIdentityClient/UserAndTokenLifeCycle.json
@@ -8,10 +8,10 @@
         "Authorization": "Sanitized",
         "Content-Length": "2",
         "Content-Type": "application/json",
-        "Date": "Mon, 25 Jan 2021 18:19:51 GMT",
+        "Date": "Thu, 18 Feb 2021 01:28:58 GMT",
         "User-Agent": [
-          "azsdk-net-Communication.Identity/1.0.0-alpha.20210125.1",
-          "(.NET 5.0.2; Microsoft Windows 10.0.18363)"
+          "azsdk-net-Communication.Identity/1.0.0-alpha.20210217.1",
+          "(.NET Core 4.6.29321.03; Microsoft Windows 10.0.21313 )"
         ],
         "x-ms-client-request-id": "f9ace4fde99e08d492756d5939ec7f5e",
         "x-ms-content-sha256": "Sanitized",
@@ -22,13 +22,14 @@
       "ResponseHeaders": {
         "api-supported-versions": "2020-07-20-preview2, 2021-03-07",
         "Content-Type": "application/json; charset=utf-8",
-        "Date": "Mon, 25 Jan 2021 18:19:49 GMT",
-        "MS-CV": "3o\u002BjdkDuUkeZEqSug7nNzg.0",
+        "Date": "Thu, 18 Feb 2021 01:28:57 GMT",
+        "MS-CV": "GphRVG5jWUaKIg9kIVSoaQ.0",
+        "Request-Context": "appId=",
         "Strict-Transport-Security": "max-age=2592000",
         "Transfer-Encoding": "chunked",
-        "X-Azure-Ref": "0xQsPYAAAAACtHuwDEycyQaKRyn9UA1gJWVZSMzBFREdFMDQyMQA5ZmM3YjUxOS1hOGNjLTRmODktOTM1ZS1jOTE0OGFlMDllODE=",
+        "X-Azure-Ref": "02sItYAAAAAA4BmEuS3LLR4L61bxuh8kxV1NURURHRTA4MTAAOWZjN2I1MTktYThjYy00Zjg5LTkzNWUtYzkxNDhhZTA5ZTgx",
         "x-ms-client-request-id": "f9ace4fde99e08d492756d5939ec7f5e",
-        "X-Processing-Time": "18ms"
+        "X-Processing-Time": "10ms"
       },
       "ResponseBody": {
         "identity": {
@@ -44,10 +45,10 @@
         "Authorization": "Sanitized",
         "Content-Length": "19",
         "Content-Type": "application/json",
-        "Date": "Mon, 25 Jan 2021 18:19:51 GMT",
+        "Date": "Thu, 18 Feb 2021 01:28:58 GMT",
         "User-Agent": [
-          "azsdk-net-Communication.Identity/1.0.0-alpha.20210125.1",
-          "(.NET 5.0.2; Microsoft Windows 10.0.18363)"
+          "azsdk-net-Communication.Identity/1.0.0-alpha.20210217.1",
+          "(.NET Core 4.6.29321.03; Microsoft Windows 10.0.21313 )"
         ],
         "x-ms-client-request-id": "74542cca26c64f6c3b26b1bfe24ac2b1",
         "x-ms-content-sha256": "Sanitized",
@@ -62,44 +63,86 @@
       "ResponseHeaders": {
         "api-supported-versions": "2020-07-20-preview2, 2021-03-07",
         "Content-Type": "application/json; charset=utf-8",
-        "Date": "Mon, 25 Jan 2021 18:19:49 GMT",
-        "MS-CV": "rk5kavk6q0WQ\u002BAZYkp2k6Q.0",
+        "Date": "Thu, 18 Feb 2021 01:28:57 GMT",
+        "MS-CV": "xpfMynHseEmZLb9K/GUxhQ.0",
+        "Request-Context": "appId=",
         "Strict-Transport-Security": "max-age=2592000",
         "Transfer-Encoding": "chunked",
-        "X-Azure-Ref": "0xQsPYAAAAACZ8EMETkkJQJB6f7MMbr1VWVZSMzBFREdFMDQyMQA5ZmM3YjUxOS1hOGNjLTRmODktOTM1ZS1jOTE0OGFlMDllODE=",
+        "X-Azure-Ref": "02sItYAAAAADhOEUIGgsMRboUT8DDGrzAV1NURURHRTA4MTAAOWZjN2I1MTktYThjYy00Zjg5LTkzNWUtYzkxNDhhZTA5ZTgx",
         "x-ms-client-request-id": "74542cca26c64f6c3b26b1bfe24ac2b1",
-        "X-Processing-Time": "22ms"
+        "X-Processing-Time": "24ms"
       },
       "ResponseBody": {
         "token": "Sanitized",
-        "expiresOn": "2021-01-26T18:19:48.7685981\u002B00:00"
+        "expiresOn": "2021-02-19T01:28:57.2904427\u002B00:00"
       }
     },
     {
-      "RequestUri": "https://sanitized.communication.azure.com/identities/sanitized/:revokeAccessTokens?api-version=2021-03-07",
+      "RequestUri": "https://sanitized.communication.azure.com/turn/sanitized/:issueCredentials?api-version=2021-12-12",
       "RequestMethod": "POST",
       "RequestHeaders": {
         "Accept": "application/json",
         "Authorization": "Sanitized",
-        "Date": "Mon, 25 Jan 2021 18:19:51 GMT",
+        "Date": "Thu, 18 Feb 2021 01:28:58 GMT",
         "User-Agent": [
-          "azsdk-net-Communication.Identity/1.0.0-alpha.20210125.1",
-          "(.NET 5.0.2; Microsoft Windows 10.0.18363)"
+          "azsdk-net-Communication.Identity/1.0.0-alpha.20210217.1",
+          "(.NET Core 4.6.29321.03; Microsoft Windows 10.0.21313 )"
         ],
         "x-ms-client-request-id": "09d0a92bcf8a648a7167dd20a484dcc4",
         "x-ms-content-sha256": "Sanitized",
         "x-ms-return-client-request-id": "true"
       },
       "RequestBody": null,
+      "StatusCode": 200,
+      "ResponseHeaders": {
+        "api-supported-versions": "2021-12-12",
+        "Content-Type": "application/json; charset=utf-8",
+        "Date": "Thu, 18 Feb 2021 01:28:57 GMT",
+        "MS-CV": "FiXKVatplk\u002B8CMMtnrIWEw.0",
+        "Request-Context": "appId=",
+        "Strict-Transport-Security": "max-age=2592000",
+        "Transfer-Encoding": "chunked",
+        "X-Azure-Ref": "02sItYAAAAAASCNdi4ZT4Rp89A1IinKKjV1NURURHRTA4MTAAOWZjN2I1MTktYThjYy00Zjg5LTkzNWUtYzkxNDhhZTA5ZTgx",
+        "x-ms-client-request-id": "09d0a92bcf8a648a7167dd20a484dcc4",
+        "X-Processing-Time": "56ms"
+      },
+      "ResponseBody": {
+        "expiresOn": "2021-02-18T01:28:58.385042\u002B00:00",
+        "turnServers": [
+          {
+            "urls": "Sanitized",
+            "username": "Sanitized",
+            "credential": "Sanitized"
+          }
+        ]
+      }
+    },
+    {
+      "RequestUri": "https://sanitized.communication.azure.com/identities/sanitized/:revokeAccessTokens?api-version=2021-03-07",
+      "RequestMethod": "POST",
+      "RequestHeaders": {
+        "Accept": "application/json",
+        "Authorization": "Sanitized",
+        "Date": "Thu, 18 Feb 2021 01:28:58 GMT",
+        "User-Agent": [
+          "azsdk-net-Communication.Identity/1.0.0-alpha.20210217.1",
+          "(.NET Core 4.6.29321.03; Microsoft Windows 10.0.21313 )"
+        ],
+        "x-ms-client-request-id": "9914a8c9df07d639785cbd7737142647",
+        "x-ms-content-sha256": "Sanitized",
+        "x-ms-return-client-request-id": "true"
+      },
+      "RequestBody": null,
       "StatusCode": 204,
       "ResponseHeaders": {
         "api-supported-versions": "2020-07-20-preview2, 2021-03-07",
-        "Date": "Mon, 25 Jan 2021 18:19:49 GMT",
-        "MS-CV": "7tWoGENNMku3dbt10krwmA.0",
+        "Date": "Thu, 18 Feb 2021 01:28:58 GMT",
+        "MS-CV": "8nBZpU5C30W/TDhEp8\u002BDmg.0",
+        "Request-Context": "appId=",
         "Strict-Transport-Security": "max-age=2592000",
-        "X-Azure-Ref": "0xQsPYAAAAACe9uva18cXRo4X1lTatKHQWVZSMzBFREdFMDQyMQA5ZmM3YjUxOS1hOGNjLTRmODktOTM1ZS1jOTE0OGFlMDllODE=",
-        "x-ms-client-request-id": "09d0a92bcf8a648a7167dd20a484dcc4",
-        "X-Processing-Time": "296ms"
+        "X-Azure-Ref": "02sItYAAAAABHwgjTQ2j2Qry7glKlN3n2V1NURURHRTA4MTAAOWZjN2I1MTktYThjYy00Zjg5LTkzNWUtYzkxNDhhZTA5ZTgx",
+        "x-ms-client-request-id": "9914a8c9df07d639785cbd7737142647",
+        "X-Processing-Time": "299ms"
       },
       "ResponseBody": []
     },
@@ -109,12 +152,12 @@
       "RequestHeaders": {
         "Accept": "application/json",
         "Authorization": "Sanitized",
-        "Date": "Mon, 25 Jan 2021 18:19:52 GMT",
+        "Date": "Thu, 18 Feb 2021 01:28:58 GMT",
         "User-Agent": [
-          "azsdk-net-Communication.Identity/1.0.0-alpha.20210125.1",
-          "(.NET 5.0.2; Microsoft Windows 10.0.18363)"
+          "azsdk-net-Communication.Identity/1.0.0-alpha.20210217.1",
+          "(.NET Core 4.6.29321.03; Microsoft Windows 10.0.21313 )"
         ],
-        "x-ms-client-request-id": "9914a8c9df07d639785cbd7737142647",
+        "x-ms-client-request-id": "8f2ebbb3761cfad4a1ef035e494baab7",
         "x-ms-content-sha256": "Sanitized",
         "x-ms-return-client-request-id": "true"
       },
@@ -122,12 +165,13 @@
       "StatusCode": 204,
       "ResponseHeaders": {
         "api-supported-versions": "2020-07-20-preview2, 2021-03-07",
-        "Date": "Mon, 25 Jan 2021 18:19:49 GMT",
-        "MS-CV": "5aQ/X6J3sUS/rOu\u002BnZqtzQ.0",
+        "Date": "Thu, 18 Feb 2021 01:28:58 GMT",
+        "MS-CV": "DqAtOE6mvkCbV7zW0/FkRQ.0",
+        "Request-Context": "appId=",
         "Strict-Transport-Security": "max-age=2592000",
-        "X-Azure-Ref": "0xgsPYAAAAAADsBeOnfqrQJdFXwoP3hrdWVZSMzBFREdFMDQyMQA5ZmM3YjUxOS1hOGNjLTRmODktOTM1ZS1jOTE0OGFlMDllODE=",
-        "x-ms-client-request-id": "9914a8c9df07d639785cbd7737142647",
-        "X-Processing-Time": "176ms"
+        "X-Azure-Ref": "02sItYAAAAADWTbyaJU91SoLR5hRtks1oV1NURURHRTA4MTAAOWZjN2I1MTktYThjYy00Zjg5LTkzNWUtYzkxNDhhZTA5ZTgx",
+        "x-ms-client-request-id": "8f2ebbb3761cfad4a1ef035e494baab7",
+        "X-Processing-Time": "501ms"
       },
       "ResponseBody": []
     }
diff --git a/sdk/communication/Azure.Communication.Identity/tests/SessionRecords/Sample1_CommunicationIdentityClient/UserAndTokenLifeCycleAsyncAsync.json b/sdk/communication/Azure.Communication.Identity/tests/SessionRecords/Sample1_CommunicationIdentityClient/UserAndTokenLifeCycleAsyncAsync.json
index d59667d88b4d..e734900296f1 100644
--- a/sdk/communication/Azure.Communication.Identity/tests/SessionRecords/Sample1_CommunicationIdentityClient/UserAndTokenLifeCycleAsyncAsync.json
+++ b/sdk/communication/Azure.Communication.Identity/tests/SessionRecords/Sample1_CommunicationIdentityClient/UserAndTokenLifeCycleAsyncAsync.json
@@ -8,11 +8,11 @@
         "Authorization": "Sanitized",
         "Content-Length": "2",
         "Content-Type": "application/json",
-        "Date": "Mon, 25 Jan 2021 18:19:52 GMT",
-        "traceparent": "00-66e09b6aa1602e4a977bdea3eb5c9039-a70f1ba427cc074c-00",
+        "Date": "Thu, 18 Feb 2021 01:28:59 GMT",
+        "traceparent": "00-157cd897f1e409469f604d5bde654214-62455839c5fcaf44-00",
         "User-Agent": [
-          "azsdk-net-Communication.Identity/1.0.0-alpha.20210125.1",
-          "(.NET 5.0.2; Microsoft Windows 10.0.18363)"
+          "azsdk-net-Communication.Identity/1.0.0-alpha.20210217.1",
+          "(.NET Core 4.6.29321.03; Microsoft Windows 10.0.21313 )"
         ],
         "x-ms-client-request-id": "599e3f91a5e52c4751efeb3d362c83bf",
         "x-ms-content-sha256": "Sanitized",
@@ -23,13 +23,14 @@
       "ResponseHeaders": {
         "api-supported-versions": "2020-07-20-preview2, 2021-03-07",
         "Content-Type": "application/json; charset=utf-8",
-        "Date": "Mon, 25 Jan 2021 18:19:50 GMT",
-        "MS-CV": "erULDP876UqeEyUSpY7FGA.0",
+        "Date": "Thu, 18 Feb 2021 01:28:59 GMT",
+        "MS-CV": "d/MM4K2MsEOZzqZ10bE3zg.0",
+        "Request-Context": "appId=",
         "Strict-Transport-Security": "max-age=2592000",
         "Transfer-Encoding": "chunked",
-        "X-Azure-Ref": "0xgsPYAAAAAAvIdETTMfbTJdn/wCyZrJiWVZSMzBFREdFMDQyMQA5ZmM3YjUxOS1hOGNjLTRmODktOTM1ZS1jOTE0OGFlMDllODE=",
+        "X-Azure-Ref": "028ItYAAAAADt4JU3Xe41S7Kr9mz08OQyV1NURURHRTA4MTAAOWZjN2I1MTktYThjYy00Zjg5LTkzNWUtYzkxNDhhZTA5ZTgx",
         "x-ms-client-request-id": "599e3f91a5e52c4751efeb3d362c83bf",
-        "X-Processing-Time": "20ms"
+        "X-Processing-Time": "10ms"
       },
       "ResponseBody": {
         "identity": {
@@ -45,11 +46,11 @@
         "Authorization": "Sanitized",
         "Content-Length": "19",
         "Content-Type": "application/json",
-        "Date": "Mon, 25 Jan 2021 18:19:52 GMT",
-        "traceparent": "00-27e527c86f456049bcba450995d35ed3-27632fa7ccd12f42-00",
+        "Date": "Thu, 18 Feb 2021 01:28:59 GMT",
+        "traceparent": "00-96243c057271af45871c64c617a2cd4e-0647d9f6b631d44c-00",
         "User-Agent": [
-          "azsdk-net-Communication.Identity/1.0.0-alpha.20210125.1",
-          "(.NET 5.0.2; Microsoft Windows 10.0.18363)"
+          "azsdk-net-Communication.Identity/1.0.0-alpha.20210217.1",
+          "(.NET Core 4.6.29321.03; Microsoft Windows 10.0.21313 )"
         ],
         "x-ms-client-request-id": "dd177535773c27b192187e24181c490b",
         "x-ms-content-sha256": "Sanitized",
@@ -64,45 +65,88 @@
       "ResponseHeaders": {
         "api-supported-versions": "2020-07-20-preview2, 2021-03-07",
         "Content-Type": "application/json; charset=utf-8",
-        "Date": "Mon, 25 Jan 2021 18:19:50 GMT",
-        "MS-CV": "jJoeO6Hsd0OxDUVRFSh4Vg.0",
+        "Date": "Thu, 18 Feb 2021 01:28:59 GMT",
+        "MS-CV": "qWCSyY8ZCUewy9IfgrNB2w.0",
+        "Request-Context": "appId=",
         "Strict-Transport-Security": "max-age=2592000",
         "Transfer-Encoding": "chunked",
-        "X-Azure-Ref": "0xgsPYAAAAAC9q\u002BcPxOvnQZYxyVL5BQDwWVZSMzBFREdFMDQyMQA5ZmM3YjUxOS1hOGNjLTRmODktOTM1ZS1jOTE0OGFlMDllODE=",
+        "X-Azure-Ref": "028ItYAAAAAAr0n4jJaq7Q53IMvXdTwVdV1NURURHRTA4MTAAOWZjN2I1MTktYThjYy00Zjg5LTkzNWUtYzkxNDhhZTA5ZTgx",
         "x-ms-client-request-id": "dd177535773c27b192187e24181c490b",
-        "X-Processing-Time": "25ms"
+        "X-Processing-Time": "26ms"
       },
       "ResponseBody": {
         "token": "Sanitized",
-        "expiresOn": "2021-01-26T18:19:49.6615966\u002B00:00"
+        "expiresOn": "2021-02-19T01:28:58.7632857\u002B00:00"
       }
     },
     {
-      "RequestUri": "https://sanitized.communication.azure.com/identities/sanitized/:revokeAccessTokens?api-version=2021-03-07",
+      "RequestUri": "https://sanitized.communication.azure.com/turn/sanitized/:issueCredentials?api-version=2021-12-12",
       "RequestMethod": "POST",
       "RequestHeaders": {
         "Accept": "application/json",
         "Authorization": "Sanitized",
-        "Date": "Mon, 25 Jan 2021 18:19:52 GMT",
-        "traceparent": "00-a0ac1c8a23e0014983a90ef2f86b1345-e985322795a14943-00",
+        "Date": "Thu, 18 Feb 2021 01:28:59 GMT",
+        "traceparent": "00-3e0283fc133c61408b476c0994f48489-5c61d4ae331c3644-00",
         "User-Agent": [
-          "azsdk-net-Communication.Identity/1.0.0-alpha.20210125.1",
-          "(.NET 5.0.2; Microsoft Windows 10.0.18363)"
+          "azsdk-net-Communication.Identity/1.0.0-alpha.20210217.1",
+          "(.NET Core 4.6.29321.03; Microsoft Windows 10.0.21313 )"
         ],
         "x-ms-client-request-id": "24686484effdecd466d71c62c8c84196",
         "x-ms-content-sha256": "Sanitized",
         "x-ms-return-client-request-id": "true"
       },
       "RequestBody": null,
+      "StatusCode": 200,
+      "ResponseHeaders": {
+        "api-supported-versions": "2021-12-12",
+        "Content-Type": "application/json; charset=utf-8",
+        "Date": "Thu, 18 Feb 2021 01:28:59 GMT",
+        "MS-CV": "OZzvCG5hMUeEuPsYLRV7lw.0",
+        "Request-Context": "appId=",
+        "Strict-Transport-Security": "max-age=2592000",
+        "Transfer-Encoding": "chunked",
+        "X-Azure-Ref": "028ItYAAAAAA9YYtAVf1iQJuyP\u002Bn9kRflV1NURURHRTA4MTAAOWZjN2I1MTktYThjYy00Zjg5LTkzNWUtYzkxNDhhZTA5ZTgx",
+        "x-ms-client-request-id": "24686484effdecd466d71c62c8c84196",
+        "X-Processing-Time": "53ms"
+      },
+      "ResponseBody": {
+        "expiresOn": "2021-02-18T01:28:59.8517469\u002B00:00",
+        "turnServers": [
+          {
+            "urls": "Sanitized",
+            "username": "Sanitized",
+            "credential": "Sanitized"
+          }
+        ]
+      }
+    },
+    {
+      "RequestUri": "https://sanitized.communication.azure.com/identities/sanitized/:revokeAccessTokens?api-version=2021-03-07",
+      "RequestMethod": "POST",
+      "RequestHeaders": {
+        "Accept": "application/json",
+        "Authorization": "Sanitized",
+        "Date": "Thu, 18 Feb 2021 01:28:59 GMT",
+        "traceparent": "00-acbde138ff69f54c821c1ebafdf60e46-0e11ac58c781be40-00",
+        "User-Agent": [
+          "azsdk-net-Communication.Identity/1.0.0-alpha.20210217.1",
+          "(.NET Core 4.6.29321.03; Microsoft Windows 10.0.21313 )"
+        ],
+        "x-ms-client-request-id": "9e29fde5a0d719fa8d77c7cc26221435",
+        "x-ms-content-sha256": "Sanitized",
+        "x-ms-return-client-request-id": "true"
+      },
+      "RequestBody": null,
       "StatusCode": 204,
       "ResponseHeaders": {
         "api-supported-versions": "2020-07-20-preview2, 2021-03-07",
-        "Date": "Mon, 25 Jan 2021 18:19:50 GMT",
-        "MS-CV": "wxaia\u002BIYfEm9esmQ4llXuA.0",
+        "Date": "Thu, 18 Feb 2021 01:28:59 GMT",
+        "MS-CV": "EA9CDCTN0ESs7ucNa3t08g.0",
+        "Request-Context": "appId=",
         "Strict-Transport-Security": "max-age=2592000",
-        "X-Azure-Ref": "0xgsPYAAAAADc7K597FhxT4EPZlIeSStzWVZSMzBFREdFMDQyMQA5ZmM3YjUxOS1hOGNjLTRmODktOTM1ZS1jOTE0OGFlMDllODE=",
-        "x-ms-client-request-id": "24686484effdecd466d71c62c8c84196",
-        "X-Processing-Time": "622ms"
+        "X-Azure-Ref": "028ItYAAAAAB3SaQ8a15GQYiCGRFcMMBqV1NURURHRTA4MTAAOWZjN2I1MTktYThjYy00Zjg5LTkzNWUtYzkxNDhhZTA5ZTgx",
+        "x-ms-client-request-id": "9e29fde5a0d719fa8d77c7cc26221435",
+        "X-Processing-Time": "582ms"
       },
       "ResponseBody": []
     },
@@ -112,13 +156,13 @@
       "RequestHeaders": {
         "Accept": "application/json",
         "Authorization": "Sanitized",
-        "Date": "Mon, 25 Jan 2021 18:19:53 GMT",
-        "traceparent": "00-907962deb82b9643914043503db0d684-55ef8ef4bdddad4e-00",
+        "Date": "Thu, 18 Feb 2021 01:29:00 GMT",
+        "traceparent": "00-64a6dae8d70d034495faba47d2d635c4-aec8dcc275110849-00",
         "User-Agent": [
-          "azsdk-net-Communication.Identity/1.0.0-alpha.20210125.1",
-          "(.NET 5.0.2; Microsoft Windows 10.0.18363)"
+          "azsdk-net-Communication.Identity/1.0.0-alpha.20210217.1",
+          "(.NET Core 4.6.29321.03; Microsoft Windows 10.0.21313 )"
         ],
-        "x-ms-client-request-id": "9e29fde5a0d719fa8d77c7cc26221435",
+        "x-ms-client-request-id": "d2b8dfa65fc346c2a12b76655a4f5fc9",
         "x-ms-content-sha256": "Sanitized",
         "x-ms-return-client-request-id": "true"
       },
@@ -126,12 +170,13 @@
       "StatusCode": 204,
       "ResponseHeaders": {
         "api-supported-versions": "2020-07-20-preview2, 2021-03-07",
-        "Date": "Mon, 25 Jan 2021 18:19:51 GMT",
-        "MS-CV": "aisGmljljkOI5ac37y9fng.0",
+        "Date": "Thu, 18 Feb 2021 01:29:00 GMT",
+        "MS-CV": "weMHxlpAq0G8MZQwcGh/BQ.0",
+        "Request-Context": "appId=",
         "Strict-Transport-Security": "max-age=2592000",
-        "X-Azure-Ref": "0xwsPYAAAAAAzrh3LLP8IT7SLq\u002BeOyBtzWVZSMzBFREdFMDQyMQA5ZmM3YjUxOS1hOGNjLTRmODktOTM1ZS1jOTE0OGFlMDllODE=",
-        "x-ms-client-request-id": "9e29fde5a0d719fa8d77c7cc26221435",
-        "X-Processing-Time": "357ms"
+        "X-Azure-Ref": "03MItYAAAAABdfQIcguxiQYHeCo\u002BAE3dIV1NURURHRTA4MTAAOWZjN2I1MTktYThjYy00Zjg5LTkzNWUtYzkxNDhhZTA5ZTgx",
+        "x-ms-client-request-id": "d2b8dfa65fc346c2a12b76655a4f5fc9",
+        "X-Processing-Time": "539ms"
       },
       "ResponseBody": []
     }
diff --git a/sdk/communication/Azure.Communication.Identity/tests/samples/Sample1_CommunicationIdentityClient.cs b/sdk/communication/Azure.Communication.Identity/tests/samples/Sample1_CommunicationIdentityClient.cs
index d68ad49abf3d..b03d8a8c6f55 100644
--- a/sdk/communication/Azure.Communication.Identity/tests/samples/Sample1_CommunicationIdentityClient.cs
+++ b/sdk/communication/Azure.Communication.Identity/tests/samples/Sample1_CommunicationIdentityClient.cs
@@ -2,7 +2,9 @@
 // Licensed under the MIT License.
 
 using System;
+using System.Collections.Generic;
 using System.Threading.Tasks;
+using Azure.Communication.Identity.Models;
 using Azure.Communication.Identity.Tests;
 using Azure.Core;
 using Azure.Core.TestFramework;
@@ -34,13 +36,13 @@ public async Task UserAndTokenLifeCycleAsync()
 
             client = CreateClientWithConnectionString();
 
-            #region  Snippet:CreateCommunicationUserAsync
+            #region Snippet:CreateCommunicationUserAsync
             Response<CommunicationUserIdentifier> userResponse = await client.CreateUserAsync();
             CommunicationUserIdentifier user = userResponse.Value;
             Console.WriteLine($"User id: {user.Id}");
-            #endregion Snippet:CreateCommunicationTokenAsync
+            #endregion Snippet:CreateCommunicationUserAsync
 
-            #region  Snippet:CreateCommunicationTokenAsync
+            #region Snippet:CreateCommunicationTokenAsync
             Response<AccessToken> tokenResponse = await client.IssueTokenAsync(user, scopes: new[] { CommunicationTokenScope.Chat });
             string token = tokenResponse.Value.Token;
             DateTimeOffset expiresOn = tokenResponse.Value.ExpiresOn;
@@ -48,6 +50,19 @@ public async Task UserAndTokenLifeCycleAsync()
             Console.WriteLine($"Expires On: {expiresOn}");
             #endregion Snippet:CreateCommunicationTokenAsync
 
+            #region Snippet:CreateTURNTokenAsync
+            Response<CommunicationTurnCredentialsResponse> turnTokenResponse = await client.IssueTurnCredentialsAsync(user);
+            DateTimeOffset turnTokenExpiresOn = turnTokenResponse.Value.ExpiresOn;
+            IReadOnlyList<CommunicationTurnServer> turnServers = turnTokenResponse.Value.TurnServers;
+            Console.WriteLine($"Expires On: {turnTokenExpiresOn}");
+            foreach (CommunicationTurnServer turnServer in turnServers)
+            {
+                Console.WriteLine($"TURN Url: {turnServer.Urls}");
+                Console.WriteLine($"TURN Username: {turnServer.Username}");
+                Console.WriteLine($"TURN Credential: {turnServer.Credential}");
+            }
+            #endregion Snippet:CreateTURNTokenAsync
+
             #region Snippet:RevokeCommunicationUserTokenAsync
             Response revokeResponse = await client.RevokeTokensAsync(user);
             #endregion Snippet:RevokeCommunicationUserTokenAsync
@@ -69,13 +84,13 @@ public void UserAndTokenLifeCycle()
             #endregion Snippet:CreateCommunicationIdentityClient
             client = CreateClientWithConnectionString();
 
-            #region  Snippet:CreateCommunicationUser
+            #region Snippet:CreateCommunicationUser
             Response<CommunicationUserIdentifier> userResponse = client.CreateUser();
             CommunicationUserIdentifier user = userResponse.Value;
             Console.WriteLine($"User id: {user.Id}");
-            #endregion Snippet:CreateCommunicationToken
+            #endregion Snippet:CreateCommunicationUser
 
-            #region  Snippet:CreateCommunicationToken
+            #region Snippet:CreateCommunicationToken
             Response<AccessToken> tokenResponse = client.IssueToken(user, scopes: new[] { CommunicationTokenScope.Chat });
             string token = tokenResponse.Value.Token;
             DateTimeOffset expiresOn = tokenResponse.Value.ExpiresOn;
@@ -83,6 +98,19 @@ public void UserAndTokenLifeCycle()
             Console.WriteLine($"Expires On: {expiresOn}");
             #endregion Snippet:CreateCommunicationToken
 
+            #region Snippet:CreateTURNToken
+            Response<CommunicationTurnCredentialsResponse> turnTokenResponse = client.IssueTurnCredentials(user);
+            DateTimeOffset turnTokenExpiresOn = turnTokenResponse.Value.ExpiresOn;
+            IReadOnlyList<CommunicationTurnServer> turnServers = turnTokenResponse.Value.TurnServers;
+            Console.WriteLine($"Expires On: {turnTokenExpiresOn}");
+            foreach (CommunicationTurnServer turnServer in turnServers)
+            {
+                Console.WriteLine($"TURN Url: {turnServer.Urls}");
+                Console.WriteLine($"TURN Username: {turnServer.Username}");
+                Console.WriteLine($"TURN Credential: {turnServer.Credential}");
+            }
+            #endregion Snippet:CreateTURNToken
+
             #region Snippet:RevokeCommunicationUserToken
             Response revokeResponse = client.RevokeTokens(user);
             #endregion Snippet:RevokeCommunicationUserToken