diff --git a/OpenPayments.Sdk.HttpSignatureUtils/HttpRequestSigner.cs b/OpenPayments.Sdk.HttpSignatureUtils/HttpRequestSigner.cs
index 320f900..a97aec0 100644
--- a/OpenPayments.Sdk.HttpSignatureUtils/HttpRequestSigner.cs
+++ b/OpenPayments.Sdk.HttpSignatureUtils/HttpRequestSigner.cs
@@ -8,7 +8,6 @@
 /// <summary>
 /// Signature headers returned by the HttpRequestSigner.
 /// </summary>
-
 public class SignatureHeaders
 {
     /// <summary>
@@ -31,13 +30,13 @@ private static string BuildSignatureInput(List<string> components, string keyId,
         var fields = string.Join(" ", components.Select(h => $"\"{h}\""));
         return $"({fields});created={created};keyid=\"{keyId}\";alg=\"ed25519\"";
     }
-    
+
     private static string ComputeContentDigest(string body)
     {
         var hash = SHA512.HashData(Encoding.UTF8.GetBytes(body));
         return Convert.ToBase64String(hash);
     }
-    
+
     private static async Task<string> TryGetHeaderValueAsync(HttpRequestMessage request, string name)
     {
         name = name.ToLowerInvariant();
diff --git a/OpenPayments.Sdk.HttpSignatureUtils/HttpSignatureValidator.cs b/OpenPayments.Sdk.HttpSignatureUtils/HttpSignatureValidator.cs
index 3aab70f..003839b 100644
--- a/OpenPayments.Sdk.HttpSignatureUtils/HttpSignatureValidator.cs
+++ b/OpenPayments.Sdk.HttpSignatureUtils/HttpSignatureValidator.cs
@@ -1,6 +1,5 @@
 using System.Text;
 using NSec.Cryptography;
-
 using OpenPayments.Sdk.HttpSignatureUtils;
 
 public class HttpSignatureValidator : IHttpSignatureValidator
@@ -38,11 +37,12 @@ public async Task<bool> ValidateSignatureAsync(HttpRequestMessage request, Jwk c
             return false;
 
         var challenge = await _builder.BuildBaseAsync(components, request, sigInput);
-        if (challenge is null)
+        if (challenge is null) 
             return false;
 
         var signatureBytes = Convert.FromBase64String(sig.Replace("sig1=", "").Replace(":", ""));
-        var publicKey = PublicKey.Import(SignatureAlgorithm.Ed25519, Base64UrlDecode(clientKey.X), KeyBlobFormat.RawPublicKey);
+        var publicKey = PublicKey.Import(SignatureAlgorithm.Ed25519, Base64UrlDecode(clientKey.X),
+            KeyBlobFormat.RawPublicKey);
 
         return SignatureAlgorithm.Ed25519.Verify(publicKey, Encoding.UTF8.GetBytes(challenge), signatureBytes);
     }
diff --git a/OpenPayments.Sdk.HttpSignatureUtils/KeyUtils.cs b/OpenPayments.Sdk.HttpSignatureUtils/KeyUtils.cs
index 1fa2397..f604044 100644
--- a/OpenPayments.Sdk.HttpSignatureUtils/KeyUtils.cs
+++ b/OpenPayments.Sdk.HttpSignatureUtils/KeyUtils.cs
@@ -59,19 +59,19 @@ public static Key LoadPem(string pem)
             throw new ArgumentException("Invalid PEM");
 
         // Parse PKCS#8 PrivateKeyInfo
-        var privInfo = PrivateKeyInfo.GetInstance(Asn1Object.FromByteArray(pemObj.Content));
+        var pkInfo = PrivateKeyInfo.GetInstance(Asn1Object.FromByteArray(pemObj.Content));
 
         // Ensure Ed25519 OID (1.3.101.112)
-        var oid = privInfo.PrivateKeyAlgorithm.Algorithm.Id;
+        var oid = pkInfo.PrivateKeyAlgorithm.Algorithm.Id;
         if (oid != "1.3.101.112")
             throw new ArgumentException($"Unexpected algorithm OID: {oid}. Expected Ed25519 (1.3.101.112).");
 
         // Extract the inner OCTET STRING (seed). For Ed25519 in PKCS#8, this is 32 bytes.
-        var privateKeyOctets = Asn1OctetString.GetInstance(privInfo.ParsePrivateKey());
+        var privateKeyOctets = Asn1OctetString.GetInstance(pkInfo.ParsePrivateKey());
         var privateKeyBytes = privateKeyOctets.GetOctets();
 
         // Some toolchains wrap the seed in another OCTET STRING layer:
-        // If length is not 32, try one more unwrap.
+        // If lenght is not 32, try one more unwrap.
         if (privateKeyBytes.Length != 32)
         {
             try
@@ -85,7 +85,7 @@ public static Key LoadPem(string pem)
         if (privateKeyBytes.Length != 32)
             throw new ArgumentException($"Ed25519 seed must be 32 bytes, got {privateKeyBytes.Length}.");
 
-        // Import into NSec as raw private key (seed)
+        // Import into NSec as a raw private key (seed)
         var algorithm = SignatureAlgorithm.Ed25519;
         var seed = privateKeyBytes.AsSpan(0, 32);
         return Key.Import(algorithm, seed, KeyBlobFormat.RawPrivateKey);
@@ -214,4 +214,4 @@ public static Key LoadOrGenerateKey(string? keyFilePath = null, GenerateKeyArgs?
 
         return GenerateKey(generateKeyArgs);
     }
-} 
\ No newline at end of file
+}
\ No newline at end of file
diff --git a/OpenPayments.Sdk/Clients/AuthenticatedClient.cs b/OpenPayments.Sdk/Clients/AuthenticatedClient.cs
index 4d74fb8..1ff5064 100644
--- a/OpenPayments.Sdk/Clients/AuthenticatedClient.cs
+++ b/OpenPayments.Sdk/Clients/AuthenticatedClient.cs
@@ -17,6 +17,7 @@ internal sealed class AuthenticatedClient(HttpClient http, Key privateKey, strin
     private readonly IAuthClientBase _authClient = new AuthClientBase(http, privateKey, keyId, clientUrl);
     private readonly IResourceClientBase _resClient = new ResourceClientBase(http, privateKey, keyId, clientUrl);
 
+    /// <inheritdoc/>
     public Task<AuthResponse> RequestGrantAsync(RequestArgs requestArgs,
         GrantCreateBody body,
         CancellationToken cancellationToken = default)
@@ -24,6 +25,7 @@ public Task<AuthResponse> RequestGrantAsync(RequestArgs requestArgs,
         return _authClient.RequestGrantAsync(requestArgs, body, cancellationToken);
     }
 
+    /// <inheritdoc/>
     public Task<AuthResponse> ContinueGrantAsync(AuthRequestArgs requestArgs,
         GrantContinueBody? body,
         CancellationToken cancellationToken = default)
@@ -32,37 +34,71 @@ public Task<AuthResponse> ContinueGrantAsync(AuthRequestArgs requestArgs,
         return _authClient.ContinueGrantAsync(requestArgs, body, cancellationToken);
     }
 
+    /// <inheritdoc/>
     public Task CancelGrantAsync(AuthRequestArgs requestArgs,
         CancellationToken cancellationToken = default)
     {
         return _authClient.CancelGrantAsync(requestArgs, cancellationToken);
     }
 
+    /// <inheritdoc/>
     public Task<RotateTokenResponse> RotateTokenAsync(AuthRequestArgs requestArgs,
         CancellationToken cancellationToken = default)
     {
         return _authClient.RotateTokenAsync(requestArgs, cancellationToken);
     }
-    
+
+    /// <inheritdoc/>
     public Task RevokeTokenAsync(AuthRequestArgs requestArgs,
         CancellationToken cancellationToken = default)
     {
         return _authClient.RevokeTokenAsync(requestArgs, cancellationToken);
     }
 
-    public Task<IncomingPaymentResponse> CreateIncomingPaymentAsync(AuthRequestArgs requestArgs, IncomingPaymentBody body,
+    /// <inheritdoc/>
+    public Task<IncomingPaymentResponse> CreateIncomingPaymentAsync(AuthRequestArgs requestArgs,
+        IncomingPaymentBody body,
         CancellationToken cancellationToken = default)
     {
         return _resClient.CreateIncomingPaymentAsync(requestArgs, body, cancellationToken);
     }
 
+    /// <inheritdoc/>
+    public Task<IncomingPaymentResponse> GetIncomingPaymentAsync(AuthRequestArgs requestArgs,
+        CancellationToken cancellationToken = default)
+    {
+        return _resClient.GetIncomingPaymentAsync(requestArgs, cancellationToken);
+    }
+
+    /// <inheritdoc cref="UnauthenticatedClient.GetIncomingPaymentAsync"/>
+    public Task<PublicIncomingPayment> GetPublicIncomingPaymentAsync(RequestArgs requestArgs, CancellationToken cancellationToken = default)
+    {
+        return base.GetIncomingPaymentAsync(requestArgs.Url.ToString(), cancellationToken);
+    }
+
+    /// <inheritdoc/>
+    public Task<ListIncomingPaymentsResponse> ListIncomingPaymentsAsync(AuthRequestArgs requestArgs,
+        ListIncomingPaymentQuery query, CancellationToken cancellationToken = default)
+    {
+        return _resClient.ListIncomingPaymentsAsync(requestArgs, query, cancellationToken);
+    }
+
+    /// <inheritdoc/>
+    public Task<IncomingPaymentResponse> CompleteIncomingPaymentsAsync(AuthRequestArgs requestArgs, CancellationToken cancellationToken = default)
+    {
+        return _resClient.CompleteIncomingPaymentAsync(requestArgs, cancellationToken);
+    }
+
+    /// <inheritdoc/>
     public Task<QuoteResponse> CreateQuoteAsync(AuthRequestArgs requestArgs, QuoteBody body,
         CancellationToken cancellationToken = default)
     {
-        return _resClient.CreateQuoteAsync(requestArgs, body, cancellationToken); 
+        return _resClient.CreateQuoteAsync(requestArgs, body, cancellationToken);
     }
 
-    public Task<OutgoingPaymentResponse> CreateOutgoingPaymentAsync(AuthRequestArgs requestArgs, OutgoingPaymentBody body,
+    /// <inheritdoc/>
+    public Task<OutgoingPaymentResponse> CreateOutgoingPaymentAsync(AuthRequestArgs requestArgs,
+        OutgoingPaymentBody body,
         CancellationToken cancellationToken = default)
     {
         return _resClient.CreateOutgoingPaymentAsync(requestArgs, body, cancellationToken);
@@ -78,4 +114,3 @@ public class AuthRequestArgs : RequestArgs
 {
     public required string AccessToken { get; set; }
 }
-
diff --git a/OpenPayments.Sdk/Clients/IAuthenticatedClient.cs b/OpenPayments.Sdk/Clients/IAuthenticatedClient.cs
index c71541e..a0ed9f4 100644
--- a/OpenPayments.Sdk/Clients/IAuthenticatedClient.cs
+++ b/OpenPayments.Sdk/Clients/IAuthenticatedClient.cs
@@ -10,32 +10,112 @@ namespace OpenPayments.Sdk.Clients;
 public interface IAuthenticatedClient : IUnauthenticatedClient
 {
     /// <summary>
-    /// Resolve a wallet-address URL (or payment pointer) and return its public metadata.
+    /// Request Grant
     /// </summary>
-    /// <param name="requestArgs">Auth Server URL Address (e.g. <c>https://auth.wallet.example</c>) and access token.</param>
+    /// <param name="requestArgs">Grant URL (e.g. <c>https://ilp.com/grant</c>) and access token.</param>
     /// <param name="body">Request body</param>
     /// <param name="cancellationToken">Optional cancellation token.</param>
     public Task<AuthResponse> RequestGrantAsync(RequestArgs requestArgs,
         GrantCreateBody body,
         CancellationToken cancellationToken = default);
 
+    /// <summary>
+    /// Continue Grant
+    /// </summary>
+    /// <param name="requestArgs">Continue Grant URL (e.g. <c>https://ilp.com/continue/1234</c>) and access token.</param>
+    /// <param name="body"></param>
+    /// <param name="cancellationToken"></param>
+    /// <returns></returns>
     public Task<AuthResponse> ContinueGrantAsync(AuthRequestArgs requestArgs,
         GrantContinueBody? body = null,
         CancellationToken cancellationToken = default);
 
+    /// <summary>
+    /// Cancel Grant
+    /// </summary>
+    /// <param name="requestArgs">Cancel Grant URL (e.g. <c>https://ilp.com/grant/1234</c>) and access token.</param>
+    /// <param name="cancellationToken"></param>
+    /// <returns></returns>
     public Task CancelGrantAsync(AuthRequestArgs requestArgs,
         CancellationToken cancellationToken = default);
-    
+
+    /// <summary>
+    ///
+    /// </summary>
+    /// <param name="requestArgs">Auth Token URL Address (e.g. <c>https://ilp.com/token/1234</c>) and access token.</param>
+    /// <param name="cancellationToken"></param>
+    /// <returns></returns>
     public Task<RotateTokenResponse> RotateTokenAsync(AuthRequestArgs requestArgs, CancellationToken cancellationToken = default);
 
+    /// <summary>
+    ///
+    /// </summary>
+    /// <param name="requestArgs">Auth Token URL Address (e.g. <c>https://ilp.com/token/1234</c>) and access token.</param>
+    /// <param name="cancellationToken"></param>
+    /// <returns></returns>
     public Task RevokeTokenAsync(AuthRequestArgs requestArgs, CancellationToken cancellationToken = default);
 
+    /// <summary>
+    ///
+    /// </summary>
+    /// <param name="requestArgs">Resource Server URL Address (e.g. <c>https://res.ilp.com/incoming/</c>) and access token.</param>
+    /// <param name="body"></param>
+    /// <param name="cancellationToken"></param>
+    /// <returns></returns>
     public Task<IncomingPaymentResponse> CreateIncomingPaymentAsync(AuthRequestArgs requestArgs,
         IncomingPaymentBody body, CancellationToken cancellationToken = default);
 
+
+    /// <summary>
+    /// Get an Incoming Payment
+    /// </summary>
+    /// <param name="requestArgs"></param>
+    /// <param name="cancellationToken"></param>
+    /// <returns>IncomingPaymentResponse</returns>
+    public Task<IncomingPaymentResponse> GetIncomingPaymentAsync(AuthRequestArgs requestArgs, CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Get a Public Incoming Payment
+    /// </summary>
+    /// <param name="requestArgs"></param>
+    /// <param name="cancellationToken"></param>
+    /// <returns></returns>
+    public Task<PublicIncomingPayment> GetPublicIncomingPaymentAsync(RequestArgs requestArgs, CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// List Incoming Payments
+    /// </summary>
+    /// <param name="requestArgs"></param>
+    /// <param name="query"></param>
+    /// <param name="cancellationToken"></param>
+    /// <returns>ListIncomingPaymentsResponse</returns>
+    public Task<ListIncomingPaymentsResponse> ListIncomingPaymentsAsync(AuthRequestArgs requestArgs, ListIncomingPaymentQuery query, CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Complete Incoming Payment
+    /// </summary>
+    /// <param name="requestArgs"></param>
+    /// <param name="cancellationToken"></param>
+    /// <returns>ListIncomingPaymentsResponse</returns>
+    public Task<IncomingPaymentResponse> CompleteIncomingPaymentsAsync(AuthRequestArgs requestArgs, CancellationToken cancellationToken = default);
+
+    /// <summary>
+    ///
+    /// </summary>
+    /// <param name="requestArgs">Resource Server URL Address (e.g. <c>https://res.ilp.com/quote</c>) and access token.</param>
+    /// <param name="body"></param>
+    /// <param name="cancellationToken"></param>
+    /// <returns></returns>
     public Task<QuoteResponse> CreateQuoteAsync(AuthRequestArgs requestArgs, QuoteBody body,
         CancellationToken cancellationToken = default);
 
+    /// <summary>
+    ///
+    /// </summary>
+    /// <param name="requestArgs">Resource Server URL Address (e.g. <c>https://res.ilp.com/outgoing</c>) and access token.</param>
+    /// <param name="body"></param>
+    /// <param name="cancellationToken"></param>
+    /// <returns></returns>
     public Task<OutgoingPaymentResponse> CreateOutgoingPaymentAsync(AuthRequestArgs requestArgs, OutgoingPaymentBody body,
         CancellationToken cancellationToken = default);
 }
\ No newline at end of file
diff --git a/OpenPayments.Sdk/Clients/ResourceClientBase.cs b/OpenPayments.Sdk/Clients/ResourceClientBase.cs
index 56e93bf..9e2fe7b 100644
--- a/OpenPayments.Sdk/Clients/ResourceClientBase.cs
+++ b/OpenPayments.Sdk/Clients/ResourceClientBase.cs
@@ -21,7 +21,32 @@ public async Task<IncomingPaymentResponse> CreateIncomingPaymentAsync(AuthReques
     {
         _client.BaseUrl = requestArgs.Url.ToString();
 
-        return await _client.PostIncomingPaymentAsync(body, requestArgs.AccessToken!, cancellationToken);
+        return await _client.PostIncomingPaymentAsync(body, requestArgs.AccessToken, cancellationToken);
+    }
+
+    public async Task<IncomingPaymentResponse> GetIncomingPaymentAsync(AuthRequestArgs requestArgs,
+        CancellationToken cancellationToken = default)
+    {
+        _client.BaseUrl = requestArgs.Url.ToString();
+
+        return await _client.GetIncomingPaymentAsync(requestArgs.AccessToken, cancellationToken);
+    }
+
+    public async Task<IncomingPaymentResponse> CompleteIncomingPaymentAsync(AuthRequestArgs requestArgs,
+        CancellationToken cancellationToken = default)
+    {
+        _client.BaseUrl = requestArgs.Url.ToString();
+
+        return await _client.CompleteIncomingPaymentAsync(requestArgs.AccessToken, cancellationToken);
+    }
+
+    public async Task<ListIncomingPaymentsResponse> ListIncomingPaymentsAsync(AuthRequestArgs requestArgs,
+        ListIncomingPaymentQuery query, CancellationToken cancellationToken = default)
+    {
+        _client.BaseUrl = requestArgs.Url.ToString();
+
+        return await _client.ListIncomingPaymentsAsync(requestArgs.AccessToken, query.WalletAddress, query.Cursor,
+            query.First, query.Last, cancellationToken);
     }
 
     public async Task<QuoteResponse> CreateQuoteAsync(AuthRequestArgs requestArgs, QuoteBody body,
@@ -29,7 +54,7 @@ public async Task<QuoteResponse> CreateQuoteAsync(AuthRequestArgs requestArgs, Q
     {
         _client.BaseUrl = requestArgs.Url.ToString();
 
-        return await _client.PostQuoteAsync(body, requestArgs.AccessToken!, cancellationToken);
+        return await _client.PostQuoteAsync(body, requestArgs.AccessToken, cancellationToken);
     }
 
     public async Task<OutgoingPaymentResponse> CreateOutgoingPaymentAsync(AuthRequestArgs requestArgs,
@@ -37,7 +62,7 @@ public async Task<OutgoingPaymentResponse> CreateOutgoingPaymentAsync(AuthReques
     {
         _client.BaseUrl = requestArgs.Url.ToString();
 
-        return await _client.PostOutgoingPaymentAsync(body, requestArgs.AccessToken!, cancellationToken);
+        return await _client.PostOutgoingPaymentAsync(body, requestArgs.AccessToken, cancellationToken);
     }
 }
 
@@ -46,9 +71,19 @@ public interface IResourceClientBase
     public Task<IncomingPaymentResponse> CreateIncomingPaymentAsync(AuthRequestArgs requestArgs, Body body,
         CancellationToken cancellationToken = default);
 
+    public Task<IncomingPaymentResponse> GetIncomingPaymentAsync(AuthRequestArgs requestArgs,
+        CancellationToken cancellationToken = default);
+
+    public Task<IncomingPaymentResponse> CompleteIncomingPaymentAsync(AuthRequestArgs requestArgs,
+        CancellationToken cancellationToken = default);
+
+    public Task<ListIncomingPaymentsResponse> ListIncomingPaymentsAsync(AuthRequestArgs requestArgs,
+        ListIncomingPaymentQuery query, CancellationToken cancellationToken = default);
+
     public Task<QuoteResponse> CreateQuoteAsync(AuthRequestArgs requestArgs, QuoteBody body,
         CancellationToken cancellationToken = default);
 
-    public Task<OutgoingPaymentResponse> CreateOutgoingPaymentAsync(AuthRequestArgs requestArgs, OutgoingPaymentBody body,
+    public Task<OutgoingPaymentResponse> CreateOutgoingPaymentAsync(AuthRequestArgs requestArgs,
+        OutgoingPaymentBody body,
         CancellationToken cancellationToken = default);
 }
\ No newline at end of file
diff --git a/OpenPayments.Sdk/Clients/UnauthenticatedClient.cs b/OpenPayments.Sdk/Clients/UnauthenticatedClient.cs
index 6a13818..501888b 100644
--- a/OpenPayments.Sdk/Clients/UnauthenticatedClient.cs
+++ b/OpenPayments.Sdk/Clients/UnauthenticatedClient.cs
@@ -1,3 +1,4 @@
+using System.Net.Http.Headers;
 using Newtonsoft.Json;
 using OpenPayments.Sdk.Generated.Wallet;
 using OpenPayments.Sdk.Generated.Resource;
@@ -34,10 +35,8 @@ public async Task<PublicIncomingPayment> GetIncomingPaymentAsync(string incoming
         if (string.IsNullOrWhiteSpace(incomingPaymentUrl))
             throw new ArgumentException("Value cannot be null or whitespace.", nameof(incomingPaymentUrl));
 
-        using var request = new HttpRequestMessage(HttpMethod.Get, incomingPaymentUrl)
-        {
-            Headers = { Accept = { new("application/json") } }
-        };
+        using var request = new HttpRequestMessage(HttpMethod.Get, incomingPaymentUrl);
+        request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
 
         using var response = await _httpClient.SendAsync(request, cancellationToken).ConfigureAwait(false);
         response.EnsureSuccessStatusCode();
diff --git a/OpenPayments.Sdk/Generated/Resource/ResourceServerClient.Methods.IncomingPayment.cs b/OpenPayments.Sdk/Generated/Resource/ResourceServerClient.Methods.IncomingPayment.cs
index f5a61a8..1a54f19 100644
--- a/OpenPayments.Sdk/Generated/Resource/ResourceServerClient.Methods.IncomingPayment.cs
+++ b/OpenPayments.Sdk/Generated/Resource/ResourceServerClient.Methods.IncomingPayment.cs
@@ -37,7 +37,6 @@ public async Task<IncomingPaymentResponse> PostIncomingPaymentAsync(Body body,
         ArgumentException.ThrowIfNullOrWhiteSpace(accessToken);
 
         var client = _httpClient;
-
         using var request = new HttpRequestMessage();
         var json = JsonConvert.SerializeObject(body, JsonSerializerSettings);
         var content = new StringContent(json);
@@ -49,7 +48,6 @@ public async Task<IncomingPaymentResponse> PostIncomingPaymentAsync(Body body,
 
         var urlBuilder = new StringBuilder();
         if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder.Append(_baseUrl);
-        // Operation Path: "incoming-payments"
         urlBuilder.Append("incoming-payments");
 
         PrepareRequest(client, request, urlBuilder);
@@ -97,7 +95,8 @@ await ReadObjectResponseAsync<ErrorResponse>(response, headers, cancellationToke
                             objectResponse.Text, headers, null);
                     }
 
-                    throw new ApiException<ErrorResponse>(Helpers.StatusAsText(status), status, objectResponse.Text,
+                    throw new ApiException<ErrorResponse>(objectResponse.Object.Error.Description, status,
+                        objectResponse.Text,
                         headers,
                         objectResponse.Object, null);
                 }
@@ -116,4 +115,305 @@ await ReadObjectResponseAsync<ErrorResponse>(response, headers, cancellationToke
             response.Dispose();
         }
     }
+
+    /// <summary>
+    /// Get an Incoming Payment
+    /// </summary>
+    /// <remarks>
+    /// A client can fetch the latest state of an incoming payment to determine the amount received into the wallet address.
+    /// </remarks>
+    /// <param name="accessToken">Access Token.</param>
+    /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+    /// <returns>Incoming Payment Found</returns>
+    /// <exception cref="ApiException">A server side error occurred.</exception>
+    public virtual async Task<IncomingPaymentResponse> GetIncomingPaymentAsync(string accessToken,
+        CancellationToken cancellationToken)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(accessToken);
+
+        var client = _httpClient;
+        using var request = new HttpRequestMessage();
+        request.Method = new HttpMethod("GET");
+        request.Headers.Accept.Add(MediaTypeWithQualityHeaderValue.Parse("application/json"));
+        request.Headers.Authorization = new AuthenticationHeaderValue("GNAP", $"{accessToken}");
+
+        var urlBuilder = new StringBuilder(_baseUrl);
+
+        PrepareRequest(client, request, urlBuilder);
+
+        var url = urlBuilder.ToString();
+        request.RequestUri = new Uri(url, UriKind.RelativeOrAbsolute);
+
+        PrepareRequest(client, request, url);
+
+        var response = await client
+            .SendAsync(request, HttpCompletionOption.ResponseHeadersRead, cancellationToken)
+            .ConfigureAwait(false);
+
+        try
+        {
+            var headers = Helpers.ExtractHeaders(response);
+
+            ProcessResponse(client, response);
+
+            var status = (int)response.StatusCode;
+            switch (status)
+            {
+                case 200:
+                {
+                    var objectResponse =
+                        await ReadObjectResponseAsync<IncomingPaymentResponse>(response, headers, cancellationToken)
+                            .ConfigureAwait(false);
+                    if (objectResponse.Object == null)
+                    {
+                        throw new ApiException("Response was null which was not expected.", status,
+                            objectResponse.Text, headers, null);
+                    }
+
+                    return objectResponse.Object;
+                }
+                case 401:
+                case 403:
+                case 404:
+                {
+                    var objectResponse =
+                        await ReadObjectResponseAsync<ErrorResponse>(response, headers, cancellationToken)
+                            .ConfigureAwait(false);
+                    if (objectResponse.Object == null)
+                    {
+                        throw new ApiException("Response was null which was not expected.", status,
+                            objectResponse.Text, headers, null);
+                    }
+
+                    throw new ApiException<ErrorResponse>(objectResponse.Object.Error.Description, status,
+                        objectResponse.Text,
+                        headers, objectResponse.Object, null);
+                }
+                default:
+                {
+                    var responseData =
+                        await ReadAsStringAsync(response.Content, cancellationToken).ConfigureAwait(false);
+                    throw new ApiException(
+                        "The HTTP status code of the response was not expected (" + status + ").", status,
+                        responseData, headers, null);
+                }
+            }
+        }
+        finally
+        {
+            response.Dispose();
+        }
+    }
+
+    /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+    /// <summary>
+    /// List Incoming Payments
+    /// </summary>
+    /// <remarks>
+    /// List all incoming payments on the wallet address
+    /// </remarks>
+    /// <param name="accessToken">Access Token</param>
+    /// <param name="walletAddress">URL of a wallet address hosted by a Rafiki instance.</param>
+    /// <param name="cursor">The cursor key to list from.</param>
+    /// <param name="first">The number of items to return after the cursor.</param>
+    /// <param name="last">The number of items to return before the cursor.</param>
+    /// <returns>OK</returns>
+    /// <exception cref="ApiException">A server side error occurred.</exception>
+    public virtual async Task<ListIncomingPaymentsResponse> ListIncomingPaymentsAsync(
+        string accessToken, string walletAddress, string? cursor, int? first, int? last,
+        CancellationToken cancellationToken
+    )
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(accessToken);
+        ArgumentException.ThrowIfNullOrWhiteSpace(walletAddress);
+
+        var client = _httpClient;
+        using var request = new HttpRequestMessage();
+        request.Method = new HttpMethod("GET");
+        request.Headers.Accept.Add(MediaTypeWithQualityHeaderValue.Parse("application/json"));
+        request.Headers.Authorization = new AuthenticationHeaderValue("GNAP", $"{accessToken}");
+
+        var urlBuilder = new StringBuilder();
+        if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder.Append(_baseUrl);
+        urlBuilder.Append("incoming-payments");
+        urlBuilder.Append('?');
+        urlBuilder.Append(Uri.EscapeDataString("wallet-address")).Append('=').Append(
+            Uri.EscapeDataString(ConvertToString(walletAddress, System.Globalization.CultureInfo.InvariantCulture)));
+
+        if (cursor != null)
+        {
+            urlBuilder.Append('&').Append(Uri.EscapeDataString("cursor")).Append('=')
+                .Append(
+                    Uri.EscapeDataString(ConvertToString(cursor, System.Globalization.CultureInfo.InvariantCulture)));
+        }
+
+        if (first != null)
+        {
+            urlBuilder.Append('&').Append(Uri.EscapeDataString("first")).Append('=')
+                .Append(Uri.EscapeDataString(ConvertToString(first,
+                    System.Globalization.CultureInfo.InvariantCulture)));
+        }
+
+        if (last != null)
+        {
+            urlBuilder.Append('&').Append(Uri.EscapeDataString("last")).Append('=')
+                .Append(Uri.EscapeDataString(ConvertToString(last, System.Globalization.CultureInfo.InvariantCulture)));
+        }
+
+        PrepareRequest(client, request, urlBuilder);
+
+        var url = urlBuilder.ToString();
+        request.RequestUri = new Uri(url, UriKind.RelativeOrAbsolute);
+
+        PrepareRequest(client, request, url);
+
+        var response = await client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, cancellationToken)
+            .ConfigureAwait(false);
+
+        try
+        {
+            var headers = Helpers.ExtractHeaders(response);
+
+            ProcessResponse(client, response);
+
+            var status = (int)response.StatusCode;
+            switch (status)
+            {
+                case 200:
+                {
+                    var objectResponse =
+                        await ReadObjectResponseAsync<ListIncomingPaymentsResponse>(response, headers,
+                                cancellationToken)
+                            .ConfigureAwait(false);
+                    if (objectResponse.Object == null)
+                    {
+                        throw new ApiException("Response was null which was not expected.", status, objectResponse.Text,
+                            headers, null);
+                    }
+
+                    return objectResponse.Object;
+                }
+                case 401:
+                case 403:
+                {
+                    var objectResponse =
+                        await ReadObjectResponseAsync<ErrorResponse>(response, headers, cancellationToken)
+                            .ConfigureAwait(false);
+                    if (objectResponse.Object == null)
+                    {
+                        throw new ApiException("Response was null which was not expected.", status, objectResponse.Text,
+                            headers, null);
+                    }
+
+                    throw new ApiException<ErrorResponse>(objectResponse.Object.Error.Description, status,
+                        objectResponse.Text, headers,
+                        objectResponse.Object, null);
+                }
+                default:
+                {
+                    var responseData =
+                        await ReadAsStringAsync(response.Content, cancellationToken).ConfigureAwait(false);
+                    throw new ApiException("The HTTP status code of the response was not expected (" + status + ").",
+                        status, responseData, headers, null);
+                }
+            }
+        }
+        finally
+        {
+            response.Dispose();
+        }
+    }
+
+    /// <summary>
+    /// Complete an Incoming Payment
+    /// </summary>
+    /// <remarks>
+    /// A client with the appropriate permissions MAY mark a non-expired **incoming payment** as `completed` indicating that the client is not going to make any further payments toward this **incoming payment**, even though the full `incomingAmount` may not have been received.
+    /// <br/>
+    /// <br/>This indicates to the receiving Account Servicing Entity that it can begin any post processing of the payment such as generating account statements or notifying the account holder of the completed payment.
+    /// </remarks>
+    /// <param name="accessToken"></param>
+    /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+    /// <returns>OK</returns>
+    /// <exception cref="ApiException">A server side error occurred.</exception>
+    public virtual async Task<IncomingPaymentResponse> CompleteIncomingPaymentAsync(
+        string accessToken, CancellationToken cancellationToken)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(accessToken);
+
+        var client = _httpClient;
+        using var request = new HttpRequestMessage();
+        request.Content = new StringContent(string.Empty, Encoding.UTF8, "application/json");
+        request.Method = new HttpMethod("POST");
+        request.Headers.Accept.Add(MediaTypeWithQualityHeaderValue.Parse("application/json"));
+        request.Headers.Authorization = new AuthenticationHeaderValue("GNAP", $"{accessToken}");
+
+        var urlBuilder = new StringBuilder(_baseUrl);
+        urlBuilder.Append("/complete");
+
+        PrepareRequest(client, request, urlBuilder);
+
+        var url = urlBuilder.ToString();
+        request.RequestUri = new Uri(url, UriKind.RelativeOrAbsolute);
+
+        PrepareRequest(client, request, url);
+
+        var response = await client
+            .SendAsync(request, HttpCompletionOption.ResponseHeadersRead, cancellationToken)
+            .ConfigureAwait(false);
+
+        try
+        {
+            var headers = Helpers.ExtractHeaders(response);
+
+            ProcessResponse(client, response);
+
+            var status = (int)response.StatusCode;
+            switch (status)
+            {
+                case 200:
+                {
+                    var objectResponse =
+                        await ReadObjectResponseAsync<IncomingPaymentResponse>(response, headers, cancellationToken)
+                            .ConfigureAwait(false);
+                    if (objectResponse.Object == null)
+                    {
+                        throw new ApiException("Response was null which was not expected.", status,
+                            objectResponse.Text, headers, null);
+                    }
+
+                    return objectResponse.Object;
+                }
+                case 401:
+                case 403:
+                case 404:
+                {
+                    var objectResponse =
+                        await ReadObjectResponseAsync<ErrorResponse>(response, headers, cancellationToken)
+                            .ConfigureAwait(false);
+                    if (objectResponse.Object == null)
+                    {
+                        throw new ApiException("Response was null which was not expected.", status,
+                            objectResponse.Text, headers, null);
+                    }
+
+                    throw new ApiException<ErrorResponse>(objectResponse.Object.Error.Description, status,
+                        objectResponse.Text, headers,
+                        objectResponse.Object, null);
+                }
+                default:
+                {
+                    var responseData =
+                        await ReadAsStringAsync(response.Content, cancellationToken).ConfigureAwait(false);
+                    throw new ApiException(
+                        "The HTTP status code of the response was not expected (" + status + ").", status,
+                        responseData, headers, null);
+                }
+            }
+        }
+        finally
+        {
+            response.Dispose();
+        }
+    }
 }
\ No newline at end of file
diff --git a/OpenPayments.Sdk/Generated/Resource/Types.cs b/OpenPayments.Sdk/Generated/Resource/Types.cs
index cbfaf5e..3b45708 100644
--- a/OpenPayments.Sdk/Generated/Resource/Types.cs
+++ b/OpenPayments.Sdk/Generated/Resource/Types.cs
@@ -24,16 +24,31 @@ public partial class IncomingPaymentResponse : IncomingPaymentWithMethods
         public new object? Metadata { get; set; }
     }
 
+    public partial class ListIncomingPaymentQuery
+    {
+        public required string WalletAddress { get; set; }
+        public string? Cursor { get; set; }
+        public int? First { get; set; }
+        public int? Last { get; set; }
+    }
+
+    public partial class ListIncomingPaymentsResponse : Response
+    {
+
+    }
+
     public partial class QuoteBody : Body3
     {
         /// <summary>
         /// The fixed amount that would be paid into the receiving wallet address given a successful outgoing payment.
         /// </summary>
+        [JsonProperty("receiveAmount")]
         public Amount? ReceiveAmount { get; set; }
 
         /// <summary>
         /// The fixed amount that would be sent from the sending wallet address given a successful outgoing payment.
         /// </summary>
+        [JsonProperty("debitAmount")]
         public Amount? DebitAmount { get; set; }
     }
 
@@ -69,7 +84,7 @@ public partial class OutgoingPaymentBody : Body2
     public partial class OutgoingPaymentResponse : OutgoingPaymentWithSpentAmounts
     {
     }
-    
+
     public partial class Amount
     {
         public Amount() {}
diff --git a/OpenPayments.Snippets/Program.cs b/OpenPayments.Snippets/Program.cs
index 6d746ea..21b2eb6 100644
--- a/OpenPayments.Snippets/Program.cs
+++ b/OpenPayments.Snippets/Program.cs
@@ -93,21 +93,24 @@
 {
     resourceUrlOption
 };
-
 var createIncomingPaymentCommand = new Command("CreateIncomingPayment")
 {
     receiverWalletAddressOption,
     amountOption
 };
+var listIncomingPaymentsCommand = new Command("ListIncomingPayments")
+{
+    receiverWalletAddressOption
+};
 var createQuoteCommand = new Command("CreateQuote")
 {
-    senderWalletAddressOption,  
+    senderWalletAddressOption,
     incomingPaymentIdOption
 };
 var createOutgoingPaymentCommand = new Command("CreateOutgoingPayment")
 {
-    senderWalletAddressOption,  
-    quoteUrlOption,  
+    senderWalletAddressOption,
+    quoteUrlOption,
     amountOption
 };
 
@@ -139,7 +142,6 @@
 {
     var receiver = result.GetValue(receiverWalletAddressOption)!;
     var amount = result.GetValue(amountOption)!;
-    
     var service = provider.GetRequiredService<IncomingPaymentService>();
     await service.CreateIncomingPaymentAsync(receiver, amount);
 });
@@ -148,7 +150,6 @@
 {
     var incomingPaymentUrl = result.GetValue(incomingPaymentIdOption)!;
     var sender = result.GetValue(senderWalletAddressOption)!;
-    
     var service = provider.GetRequiredService<QuoteService>();
     await service.CreateQuoteAsync(sender, incomingPaymentUrl);
 });
@@ -158,7 +159,6 @@
     var sender = result.GetValue(senderWalletAddressOption)!;
     var quoteUrl = result.GetValue(quoteUrlOption)!;
     var debitAmount = result.GetValue(amountOption)!;
-    
     var service = provider.GetRequiredService<OutgoingPaymentService>();
     await service.CreateOutgoingPaymentAsync(sender, quoteUrl, debitAmount);
 });
@@ -181,9 +181,17 @@
     }
 });
 
+listIncomingPaymentsCommand.SetAction(async result =>
+{
+    var receiver = result.GetValue(receiverWalletAddressOption)!;
+    var service = provider.GetRequiredService<IncomingPaymentService>();
+
+    await service.ListIncomingPaymentsAsync(receiver);
+});
+
 rootCommand.SetAction(_ =>
 {
-    
+
 });
 
 // Unauthenticated
@@ -192,9 +200,9 @@
 
 // Authenticated
 rootCommand.Add(createIncomingPaymentCommand);
+rootCommand.Add(listIncomingPaymentsCommand);
 rootCommand.Add(createQuoteCommand);
 rootCommand.Add(createOutgoingPaymentCommand);
 
-
 var config = new CommandLineConfiguration(rootCommand);
 return await config.InvokeAsync(args);
\ No newline at end of file
diff --git a/OpenPayments.Snippets/Services/Authenticated/IncomingPaymentService.cs b/OpenPayments.Snippets/Services/Authenticated/IncomingPaymentService.cs
index 6f4a12c..d8871bb 100644
--- a/OpenPayments.Snippets/Services/Authenticated/IncomingPaymentService.cs
+++ b/OpenPayments.Snippets/Services/Authenticated/IncomingPaymentService.cs
@@ -1,3 +1,4 @@
+using Newtonsoft.Json;
 using OpenPayments.Sdk.Clients;
 using OpenPayments.Sdk.Generated.Auth;
 using OpenPayments.Sdk.Generated.Resource;
@@ -10,7 +11,6 @@ public class IncomingPaymentService(IAuthenticatedClient client)
     public async Task<IncomingPaymentResponse> CreateIncomingPaymentAsync(string receiver, string amount)
     {
         var waDetails = await client.GetWalletAddressAsync(receiver);
-        
         var grant = await client.RequestGrantAsync(
             new RequestArgs()
             {
@@ -49,12 +49,95 @@ public async Task<IncomingPaymentResponse> CreateIncomingPaymentAsync(string rec
                 }
             }
         );
-        
+
+
+        Console.WriteLine("===Incoming Payment===");
+        Console.WriteLine("grant: {0}", JsonConvert.SerializeObject(grant, Formatting.None));
+        Console.WriteLine("AccessToken: {0}", grant.AccessToken!.Value);
+        Console.WriteLine("Id: {0}", iPaymentResponse.Id);
+        Console.WriteLine("Amount: {0}", iPaymentResponse.IncomingAmount.Value);
+        Console.WriteLine("ExpiresAt: {0}", iPaymentResponse.ExpiresAt);
+
+        return iPaymentResponse;
+    }
+
+    public async Task<IncomingPaymentResponse> GetIncomingPaymentAsync(string incomingPaymentUrl, string accessToken,
+        string tokenUrl)
+    {
+        var rotatedToken = await client.RotateTokenAsync(new AuthRequestArgs()
+        {
+            Url = new Uri(tokenUrl),
+            AccessToken = accessToken
+        });
+
+
+        var iPaymentResponse = await client.GetIncomingPaymentAsync(new AuthRequestArgs()
+        {
+            Url = new Uri(incomingPaymentUrl),
+            AccessToken = rotatedToken.AccessToken.Value
+        });
+
         Console.WriteLine("===Incoming Payment===");
         Console.WriteLine("Id: {0}", iPaymentResponse.Id);
         Console.WriteLine("Amount: {0}", iPaymentResponse.IncomingAmount.Value);
         Console.WriteLine("ExpiresAt: {0}", iPaymentResponse.ExpiresAt);
+        Console.WriteLine("Access Token Manage: {0}", rotatedToken.AccessToken.Manage);
+        Console.WriteLine("Access Token Value: {0}", rotatedToken.AccessToken.Value);
 
         return iPaymentResponse;
     }
+
+    public async Task CompleteIncomingPaymentAsync(string incomingPaymentUrl, string accessToken, string tokenUrl)
+    {
+    }
+
+    public async Task<ListIncomingPaymentsResponse> ListIncomingPaymentsAsync(string walletAddress)
+    {
+        var waDetails = await client.GetWalletAddressAsync("https://ilp.interledger-test.dev/cozmin");
+
+        var grant = await client.RequestGrantAsync(
+            new RequestArgs()
+            {
+                Url = waDetails.AuthServer
+            },
+            new GrantCreateBody()
+            {
+                AccessToken = new AccessToken()
+                {
+                    Access =
+                    [
+                        new AccessItem()
+                        {
+                            Type = AccessType.IncomingPayment,
+                            Actions = [Actions.List]
+                        }
+                    ]
+                }
+            }
+        );
+
+        var list = await client.ListIncomingPaymentsAsync(new AuthRequestArgs()
+            {
+                Url = waDetails.ResourceServer,
+                AccessToken = grant.AccessToken!.Value
+            },
+            new ListIncomingPaymentQuery()
+            {
+                WalletAddress = waDetails.Id.ToString(),
+            }
+        );
+
+        Console.WriteLine(JsonConvert.SerializeObject(list, Formatting.Indented));
+
+        foreach (var iPayment in list.Result)
+        {
+            Console.WriteLine("===Incoming Payment===");
+            Console.WriteLine("Id: {0}", iPayment.Id);
+            Console.WriteLine("Completed: {0}", iPayment.Completed ? "Yes" : "No");
+            Console.WriteLine("Amount: {0}/{1} {2}", iPayment.ReceivedAmount.Value, iPayment.IncomingAmount.Value, iPayment.ReceivedAmount.AssetCode);
+            Console.WriteLine("ExpiresAt: {0}", iPayment.ExpiresAt);
+        }
+
+        return list;
+    }
 }
\ No newline at end of file