diff --git a/Src/Support/Google.Apis.Auth.Tests/OAuth2/GoogleCredentialTests.cs b/Src/Support/Google.Apis.Auth.Tests/OAuth2/GoogleCredentialTests.cs
index 97cc76e089a..61dcd84e450 100644
--- a/Src/Support/Google.Apis.Auth.Tests/OAuth2/GoogleCredentialTests.cs
+++ b/Src/Support/Google.Apis.Auth.Tests/OAuth2/GoogleCredentialTests.cs
@@ -846,6 +846,148 @@ public async Task UniverseDomain_DifferentCustomInRequestAndCredential()
             Assert.Null(request.Headers.Authorization?.Parameter);
         }
 
+        [Theory]
+        [MemberData(nameof(CredentialFactory_Success_Data))]
+        public void FromFile_WithType(string json, string credentialType, Type expectedType)
+        {
+            var tempFile = Path.GetTempFileName();
+            try
+            {
+                File.WriteAllText(tempFile, json);
+                var credential = CredentialFactory.FromFile(tempFile, credentialType);
+                Assert.IsType(expectedType, credential.UnderlyingCredential);
+            }
+            finally
+            {
+                File.Delete(tempFile);
+            }
+        }
+
+        [Theory]
+        [MemberData(nameof(CredentialFactory_Failure_Data))]
+        public void FromFile_WithType_Failure(string json, string credentialType, string expectedMessage)
+        {
+            var tempFile = Path.GetTempFileName();
+            try
+            {
+                File.WriteAllText(tempFile, json);
+                var ex = Assert.Throws<InvalidOperationException>(() => CredentialFactory.FromFile(tempFile, credentialType));
+                Assert.Equal(expectedMessage, ex.Message);
+            }
+            finally
+            {
+                File.Delete(tempFile);
+            }
+        }
+
+        [Theory]
+        [MemberData(nameof(CredentialFactory_Success_Data))]
+        public void FromJson_WithType(string json, string credentialType, Type expectedType)
+        {
+            var credential = CredentialFactory.FromJson(json, credentialType);
+            Assert.IsType(expectedType, credential.UnderlyingCredential);
+        }
+
+        [Theory]
+        [MemberData(nameof(CredentialFactory_Failure_Data))]
+        public void FromJson_WithType_Failure(string json, string credentialType, string expectedMessage)
+        {
+            var ex = Assert.Throws<InvalidOperationException>(() => CredentialFactory.FromJson(json, credentialType));
+            Assert.Equal(expectedMessage, ex.Message);
+        }
+
+        [Theory]
+        [MemberData(nameof(CredentialFactory_Success_Data))]
+        public async Task FromFileAsync_WithType(string json, string credentialType, Type expectedType)
+        {
+            var tempFile = Path.GetTempFileName();
+            try
+            {
+                File.WriteAllText(tempFile, json);
+                var credential = await CredentialFactory.FromFileAsync(tempFile, credentialType, CancellationToken.None);
+                Assert.IsType(expectedType, credential.UnderlyingCredential);
+            }
+            finally
+            {
+                File.Delete(tempFile);
+            }
+        }
+
+        [Theory]
+        [MemberData(nameof(CredentialFactory_Failure_Data))]
+        public async Task FromFileAsync_WithType_Failure(string json, string credentialType, string expectedMessage)
+        {
+            var tempFile = Path.GetTempFileName();
+            try
+            {
+                File.WriteAllText(tempFile, json);
+                var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => CredentialFactory.FromFileAsync(tempFile, credentialType, CancellationToken.None));
+                Assert.Equal(expectedMessage, ex.Message);
+            }
+            finally
+            {
+                File.Delete(tempFile);
+            }
+        }
+
+        public static TheoryData<string, string, Type> CredentialFactory_Success_Data() =>
+            new TheoryData<string, string, Type>
+            {
+                { FakeUserCredentialFileContents, JsonCredentialParameters.AuthorizedUserCredentialType, typeof(UserCredential) },
+                { FakeServiceAccountCredentialFileContents, JsonCredentialParameters.ServiceAccountCredentialType, typeof(ServiceAccountCredential) }
+            };
+
+        public static TheoryData<string, string, string> CredentialFactory_Failure_Data() =>
+            new TheoryData<string, string, string>
+            {
+                { FakeUserCredentialFileContents, JsonCredentialParameters.ServiceAccountCredentialType, "The credential type authorized_user is not compatible with the requested type service_account" },
+                { FakeUserCredentialFileContents, "invalid_type", "The credential type authorized_user is not compatible with the requested type invalid_type" },
+                { "invalid_json", "any_type", "Error deserializing JSON credential data." }
+            };
+
+        [Fact]
+        public void FromStream_WrapsDeserializationException_WithBadJson()
+        {
+            string malformedUserCredentialFileContents = FakeUserCredentialFileContents.Replace("}","");
+            using Stream stream = new MemoryStream(Encoding.UTF8.GetBytes(malformedUserCredentialFileContents));
+            var ex = Assert.Throws<InvalidOperationException>(() => CredentialFactory.FromStream<UserCredential>(stream));
+            Assert.Equal("Error deserializing JSON credential data.", ex.Message);
+            Assert.IsType<Newtonsoft.Json.JsonSerializationException>(ex.InnerException);
+        }
+
+        [Fact]
+        public void FromStream_WrapsDeserializationException()
+        {
+            var stream = new MockStream(() => throw new Exception("Underlying exception"));
+            var ex = Assert.Throws<InvalidOperationException>(() => CredentialFactory.FromStream<UserCredential>(stream));
+            Assert.Equal("Error deserializing JSON credential data.", ex.Message);
+            Assert.IsType<Exception>(ex.InnerException);
+            Assert.Equal("Underlying exception", ex.InnerException.Message);
+        }
+
+        private class MockStream : Stream
+        {
+            private readonly Action _onRead;
+
+            public MockStream(Action onRead) => _onRead = onRead;
+
+            public override bool CanRead => true;
+            public override bool CanSeek => false;
+            public override bool CanWrite => false;
+            public override long Length => throw new NotSupportedException();
+            public override long Position { get => throw new NotSupportedException(); set => throw new NotSupportedException(); }
+
+            public override void Flush() => throw new NotSupportedException();
+            public override int Read(byte[] buffer, int offset, int count)
+            {
+                _onRead();
+                return 0;
+            }
+            public override long Seek(long offset, SeekOrigin origin) => throw new NotSupportedException();
+            public override void SetLength(long value) => throw new NotSupportedException();
+            public override void Write(byte[] buffer, int offset, int count) => throw new NotSupportedException();
+        }
+
         /// <summary>
         /// Fake implementation of <see cref="IAuthorizationCodeFlow"/> which only supports fetching the
         /// clock and the access method.
diff --git a/Src/Support/Google.Apis.Auth/OAuth2/CredentialFactory.cs b/Src/Support/Google.Apis.Auth/OAuth2/CredentialFactory.cs
index e8008862f05..dfcebd5d324 100644
--- a/Src/Support/Google.Apis.Auth/OAuth2/CredentialFactory.cs
+++ b/Src/Support/Google.Apis.Auth/OAuth2/CredentialFactory.cs
@@ -16,7 +16,6 @@ limitations under the License.
 
 using System;
 using System.IO;
-using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -32,6 +31,11 @@ namespace Google.Apis.Auth.OAuth2;
 /// </summary>
 public static class CredentialFactory
 {
+    /// <summary>
+    /// The error message for JSON deserialization failures.
+    /// </summary>
+    private const string JsonDeserializationErrorMessage = "Error deserializing JSON credential data.";
+
     /// <summary>
     /// Creates a credential of the specified type from a file that contains JSON credential data.
     /// </summary>
@@ -45,6 +49,19 @@ public static async Task<T> FromFileAsync<T>(string credentialPath, Cancellation
         return await FromStreamAsync<T>(fileStream, cancellationToken).ConfigureAwait(false);
     }
 
+    /// <summary>
+    /// Creates a credential of the specified type from a file that contains JSON credential data.
+    /// </summary>
+    /// <param name="credentialPath">The path to the credential file.</param>
+    /// <param name="credentialType">The type of credential to be loaded. Valid strings can be found in <see cref="JsonCredentialParameters"/>.</param>
+    /// <param name="cancellationToken">The cancellation token to cancel the operation.</param>
+    /// <returns>The created credential.</returns>
+    public static async Task<GoogleCredential> FromFileAsync(string credentialPath, string credentialType, CancellationToken cancellationToken)
+    {
+        using FileStream fileStream = File.OpenRead(credentialPath);
+        return await FromStreamAsync(fileStream, credentialType, cancellationToken).ConfigureAwait(false);
+    }
+
     /// <summary>
     /// Creates a credential of the specified type from a file that contains JSON credential data.
     /// </summary>
@@ -57,6 +74,18 @@ public static T FromFile<T>(string credentialPath)
         return FromStream<T>(fileStream);
     }
 
+    /// <summary>
+    /// Creates a credential of the specified type from a file that contains JSON credential data.
+    /// </summary>
+    /// <param name="credentialPath">The path to the credential file.</param>
+    /// <param name="credentialType">The type of credential to be loaded. Valid strings can be found in <see cref="JsonCredentialParameters"/>.</param>
+    /// <returns>The created credential.</returns>
+    public static GoogleCredential FromFile(string credentialPath, string credentialType)
+    {
+        using FileStream fileStream = File.OpenRead(credentialPath);
+        return FromStream(fileStream, credentialType);
+    }
+
     /// <summary>
     /// Creates a credential of the specified type from a stream that contains JSON credential data.
     /// </summary>
@@ -66,14 +95,37 @@ public static T FromFile<T>(string credentialPath)
     /// <returns>A task that will be completed with the created credential.</returns>
     public static async Task<T> FromStreamAsync<T>(Stream stream, CancellationToken cancellationToken)
     {
+        JsonCredentialParameters jsonCredentialParameters;
         try
         {
-            return FromJsonParameters<T>(await NewtonsoftJsonSerializer.Instance.DeserializeAsync<JsonCredentialParameters>(stream, cancellationToken).ConfigureAwait(false));
+            jsonCredentialParameters = await NewtonsoftJsonSerializer.Instance.DeserializeAsync<JsonCredentialParameters>(stream, cancellationToken).ConfigureAwait(false);
         }
         catch (Exception e)
         {
-            throw new InvalidOperationException("Error deserializing JSON credential data.", e);
+            throw new InvalidOperationException(JsonDeserializationErrorMessage, e);
         }
+        return FromJsonParameters<T>(jsonCredentialParameters);
+    }
+
+    /// <summary>
+    /// Creates a credential of the specified type from a stream that contains JSON credential data.
+    /// </summary>
+    /// <param name="stream">The stream that contains the JSON credential data.</param>
+    /// <param name="credentialType">The type of credential to be loaded. Valid strings can be found in <see cref="JsonCredentialParameters"/>.</param>
+    /// <param name="cancellationToken">The cancellation token to cancel the operation.</param>
+    /// <returns>The created credential.</returns>
+    private static async Task<GoogleCredential> FromStreamAsync(Stream stream, string credentialType, CancellationToken cancellationToken)
+    {
+        JsonCredentialParameters jsonCredentialParameters;
+        try
+        {
+            jsonCredentialParameters = await NewtonsoftJsonSerializer.Instance.DeserializeAsync<JsonCredentialParameters>(stream, cancellationToken).ConfigureAwait(false);
+        }
+        catch (Exception e)
+        {
+            throw new InvalidOperationException(JsonDeserializationErrorMessage, e);
+        }
+        return FromJsonParameters(jsonCredentialParameters, credentialType);
     }
 
     /// <summary>
@@ -84,14 +136,36 @@ public static async Task<T> FromStreamAsync<T>(Stream stream, CancellationToken
     /// <returns>The created credential.</returns>
     public static T FromStream<T>(Stream stream)
     {
+        JsonCredentialParameters jsonCredentialParameters;
         try
         {
-            return FromJsonParameters<T>(NewtonsoftJsonSerializer.Instance.Deserialize<JsonCredentialParameters>(stream));
+            jsonCredentialParameters = NewtonsoftJsonSerializer.Instance.Deserialize<JsonCredentialParameters>(stream);
         }
         catch (Exception e)
         {
-            throw new InvalidOperationException("Error deserializing JSON credential data.", e);
+            throw new InvalidOperationException(JsonDeserializationErrorMessage, e);
         }
+        return FromJsonParameters<T>(jsonCredentialParameters);
+    }
+
+    /// <summary>
+    /// Creates a credential of the specified type from a stream that contains JSON credential data.
+    /// </summary>
+    /// <param name="stream">The stream that contains the JSON credential data.</param>
+    /// <param name="credentialType">The type of credential to be loaded. Valid strings can be found in <see cref="JsonCredentialParameters"/>.</param>
+    /// <returns>The created credential.</returns>
+    private static GoogleCredential FromStream(Stream stream, string credentialType)
+    {
+        JsonCredentialParameters jsonCredentialParameters;
+        try
+        {
+            jsonCredentialParameters = NewtonsoftJsonSerializer.Instance.Deserialize<JsonCredentialParameters>(stream);
+        }
+        catch (Exception e)
+        {
+            throw new InvalidOperationException(JsonDeserializationErrorMessage, e);
+        }
+        return FromJsonParameters(jsonCredentialParameters, credentialType);
     }
 
     /// <summary>
@@ -102,14 +176,36 @@ public static T FromStream<T>(Stream stream)
     /// <returns>The created credential.</returns>
     public static T FromJson<T>(string json)
     {
+        JsonCredentialParameters jsonCredentialParameters;
         try
         {
-            return FromJsonParameters<T>(NewtonsoftJsonSerializer.Instance.Deserialize<JsonCredentialParameters>(json));
+            jsonCredentialParameters = NewtonsoftJsonSerializer.Instance.Deserialize<JsonCredentialParameters>(json);
         }
         catch (Exception e)
         {
-            throw new InvalidOperationException("Error deserializing JSON credential data.", e);
+            throw new InvalidOperationException(JsonDeserializationErrorMessage, e);
         }
+        return FromJsonParameters<T>(jsonCredentialParameters);
+    }
+
+    /// <summary>
+    /// Creates a credential of the specified type from a string that contains JSON credential data.
+    /// </summary>
+    /// <param name="json">The string that contains the JSON credential data.</param>
+    /// <param name="credentialType">The type of credential to be loaded. Valid strings can be found in <see cref="JsonCredentialParameters"/>.</param>
+    /// <returns>The created credential.</returns>
+    public static GoogleCredential FromJson(string json, string credentialType)
+    {
+        JsonCredentialParameters jsonCredentialParameters;
+        try
+        {
+            jsonCredentialParameters = NewtonsoftJsonSerializer.Instance.Deserialize<JsonCredentialParameters>(json);
+        }
+        catch (Exception e)
+        {
+            throw new InvalidOperationException(JsonDeserializationErrorMessage, e);
+        }
+        return FromJsonParameters(jsonCredentialParameters, credentialType);
     }
 
     /// <summary>
@@ -125,7 +221,8 @@ public static T FromJson<T>(string json)
     /// </exception>
     internal static T FromJsonParameters<T>(JsonCredentialParameters credentialParameters)
     {
-        if (CreateCredential(credentialParameters, typeof(T)) is T credentialAsT)
+        credentialParameters.ThrowIfNull(nameof(credentialParameters));
+        if (FromJsonParameters(credentialParameters, typeof(T)) is T credentialAsT)
         {
             return credentialAsT;
         }
@@ -133,19 +230,44 @@ internal static T FromJsonParameters<T>(JsonCredentialParameters credentialParam
         throw new InvalidOperationException(
             $"Found incompatible credential types, '{credentialParameters.Type}' and '{typeof(T).FullName}, even though a check" 
           + " should have already taken place. We should never reach here, there's a bug in the code.");
+    }
 
-        static IGoogleCredential CreateCredential(JsonCredentialParameters credentialParameters, Type targetCredentialType) =>
-            credentialParameters.ThrowIfNull(nameof(credentialParameters)).Type switch
-            {
-                JsonCredentialParameters.AuthorizedUserCredentialType => CreateUserCredentialFromParameters(credentialParameters, targetCredentialType),
-                JsonCredentialParameters.ServiceAccountCredentialType => CreateServiceAccountCredentialFromParameters(credentialParameters, targetCredentialType),
-                JsonCredentialParameters.ExternalAccountCredentialType => CreateExternalCredentialFromParameters(credentialParameters, targetCredentialType),
-                JsonCredentialParameters.ImpersonatedServiceAccountCredentialType => CreateImpersonatedServiceAccountCredentialFromParameters(credentialParameters, targetCredentialType),
-                JsonCredentialParameters.ExternalAccountAuthorizedUserCredentialType => CreateExternalAccountAuthorizedUserCredentialFromParameters(credentialParameters, targetCredentialType),
-                _ => throw new InvalidOperationException($"Error creating credential from JSON or JSON parameters. Unrecognized credential type {credentialParameters.Type}."),
-            };
+    /// <summary>
+    /// Creates a credential of the specified type from JSON credential parameters.
+    /// </summary>
+    /// <param name="credentialParameters">The JSON credential parameters.</param>
+    /// <param name="credentialType">The type of credential to be loaded. Valid strings can be found in <see cref="JsonCredentialParameters"/>.</param>
+    /// <returns>The created credential.</returns>
+    /// <exception cref="InvalidOperationException">
+    /// Thrown if the <paramref name="credentialType"/> is unrecognized,
+    /// or if the credential data is incompatible with the requested type.
+    /// </exception>
+    private static GoogleCredential FromJsonParameters(JsonCredentialParameters credentialParameters, string credentialType)
+    {
+        credentialParameters.ThrowIfNull(nameof(credentialParameters));
+        if (credentialParameters.Type != credentialType)
+        {
+            throw new InvalidOperationException($"The credential type {credentialParameters.Type} is not compatible with the requested type {credentialType}");
+        }
+
+        // Type checking has already occurred so target type may be set to the generic IGoogleCredential which all credentials implement.
+        Type targetType = typeof(IGoogleCredential);
+        var rawCredentialType = FromJsonParameters(credentialParameters, targetType);
+
+        return rawCredentialType.ToGoogleCredential();
     }
 
+    private static IGoogleCredential FromJsonParameters(JsonCredentialParameters credentialParameters, Type targetCredentialType) =>
+        credentialParameters.ThrowIfNull(nameof(credentialParameters)).Type switch
+        {
+            JsonCredentialParameters.AuthorizedUserCredentialType => CreateUserCredentialFromParameters(credentialParameters, targetCredentialType),
+            JsonCredentialParameters.ServiceAccountCredentialType => CreateServiceAccountCredentialFromParameters(credentialParameters, targetCredentialType),
+            JsonCredentialParameters.ExternalAccountCredentialType => CreateExternalCredentialFromParameters(credentialParameters, targetCredentialType),
+            JsonCredentialParameters.ImpersonatedServiceAccountCredentialType => CreateImpersonatedServiceAccountCredentialFromParameters(credentialParameters, targetCredentialType),
+            JsonCredentialParameters.ExternalAccountAuthorizedUserCredentialType => CreateExternalAccountAuthorizedUserCredentialFromParameters(credentialParameters, targetCredentialType),
+            _ => throw new InvalidOperationException($"Error creating credential from JSON or JSON parameters. Unrecognized credential type {credentialParameters.Type}.")
+        };
+
     /// <summary>
     /// Validates actual type can be cast to target type.
     /// </summary>