diff --git a/docs/developer-docs/integrations/t-ecdsa/index.md b/docs/developer-docs/integrations/t-ecdsa/index.md
index 71ab3b3d0b..83e5f4a310 100644
--- a/docs/developer-docs/integrations/t-ecdsa/index.md
+++ b/docs/developer-docs/integrations/t-ecdsa/index.md
@@ -1,21 +1,32 @@
 # Threshold ECDSA: chain-key signatures
-
 ## Overview
-The Internet Computer implements a novel threshold ECDSA protocol as part of its chain-key signatures toolbox. In this protocol, the private ECDSA key exists only as secret shares held by designated parties, namely the replicas of a threshold-ECDSA-enabled subnet on ICP, and signatures are computed using those secret shares without the private key ever being reconstructed. Each replica of such subnet holds a key share that provides no information on its own (in fact, any set of shares up to a threshold of one third cannot be distinguished from a set of random strings). At least one third of the replicas are required to generate a threshold signature using their respective key shares. Besides the actual threshold signing protocol, chain-key ECDSA also comprises protocols for secure key distributed key generation and periodic key resharing, which are crucial parts of the protocol. This makes chain-key ECDSA signatures much more powerful than any off-the-shelf threshold ECDSA protocol.
+The Internet Computer implements a novel threshold ECDSA protocol as part of its chain-key signatures suite. In this protocol, the private ECDSA key exists only as secret shares held by nodes. Secret shares are shards of the ECDSA private key. Signatures are computed using those secret shares without the private key ever being reconstructed. Each replica of such subnet holds a key share that provides no information on its own. More than one third of the nodes are required to generate a threshold signature using their respective key shares. 
+
+Besides the actual threshold signing protocol, chain-key ECDSA also comprises of protocols for secure, distributed key generation and periodic key resharing. Distributed key generation enables the nodes on a subnet to collaboratively generate keys, while periodic key resharing allows for ECDSA keys to be re-shared within the subnet. This makes chain-key ECDSA signatures much more powerful than any off-the-shelf threshold ECDSA protocol.
+
+Each canister on a subnet has control over a unique ECDSA public key and can request signatures for this public key. Canisters do not have access to their private ECDSA keys. They can only request signatures. This is because the private key is never stored in a single place. 
+
+Threshold ECDSA enables many important use cases:
+
+-   Canisters natively holding bitcoin.
+
+-   Integration with Ethereum and other EVM chains, such as getting ERC-20 tokens onto ICP and signing Ethereum transactions.
 
-Each canister on any subnet of the Internet Computer has control over a unique ECDSA public key and can request signatures for this public key to be computed. A signature is only issued to the eligible canister, i.e., the legitimate holder of this ECDSA key. Each canister can obtain signatures only for its own ECDSA keys. Note that canisters do not hold any private ECDSA keys or key shares themselves. Threshold cryptography can help enable functionality in the trust model of a blockchain that would be impossible to achieve with conventional cryptography alone.
+-   Integrations with other blockchains that use ECDSA as signature scheme for signing transactions.
 
-A threshold ECDSA implementation on a blockchain can be viewed as the on-chain counterpart to a hardware security module (HSM) that stores private keys securely and issues signatures on request of the eligible entities, and only to those.
+-   Realizing a decentralized certification authority (CA), where certificates are issued using threshold ECDSA.
 
-The availability of threshold ECDSA allows for a multitude of important use cases, as for example:
--   Canisters natively holding Bitcoin;
--   Integration with Ethereum, e.g., getting the ERC-20 tokens of Ethereum onto the Internet Computer Protocol or signing Ethereum transactions;
--   Integrations with other blockchains that use ECDSA as signature scheme for signing transactions;
--   Realizing a decentralized certification authority (CA), where certificates are issued using threshold ECDSA (this requires a different elliptic curve to the currently implemented curve `secp256k1`, namely `secp256r1`).
 
-Those are only a few examples for use cases of our threshold ECDSA protocol. Creative engineers and entrepreneurs will likely come up with a large number of further exciting use cases.
+## Signing transactions
+
+Threshold ECDSA can be used by making calls to the Threshold ECDSA API. 
+
+[Learn how to use Threshold ECDSA to sign transactions](./signing-transactions.mdx).
 
 ## Resources
-- If you want to learn more about chain-key ECDSA signatures, check the [how it works](./t-ecdsa-how-it-works.md) page to see more. 
-- If you want to take an even deeper dive see Groth and Shoup's [Eurocrypt 2022 paper](https://eprint.iacr.org/2021/1330).
-- Sample code for `threshold-ecdsa` is provided in the [examples repository](https://github.com/dfinity/examples), under either [`motoko`](https://github.com/dfinity/examples/tree/master/motoko/threshold-ecdsa) or [`rust`](https://github.com/dfinity/examples/tree/master/rust/threshold-ecdsa) sub-directories. 
+- [Chain-key ECDSA signatures: technology overview](./t-ecdsa-how-it-works.md).
+
+- [Eurocrypt 2022 paper](https://eprint.iacr.org/2021/1330).
+
+- [Sample code for `threshold-ecdsa`](https://github.com/dfinity/examples/tree/master/motoko/threshold-ecdsa).
+
diff --git a/docs/developer-docs/integrations/t-ecdsa/signing-transactions.mdx b/docs/developer-docs/integrations/t-ecdsa/signing-transactions.mdx
new file mode 100644
index 0000000000..b257737026
--- /dev/null
+++ b/docs/developer-docs/integrations/t-ecdsa/signing-transactions.mdx
@@ -0,0 +1,135 @@
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+# Signing transactions
+
+## Overview
+
+To use Threshold ECDSA, you will need a public key and a transaction to sign. Public keys can be obtained through the `ecdsa_public_key` API method, and transactions can be signed using the `sign_with_ecdsa` API method. 
+
+## Cost
+
+To send calls to the Threshold ECDSA API, cycles must be attached to the call. [Learn more about Threshold ECDSA costs](t-ecdsa-how-it-works.md).
+
+## Obtaining public keys
+
+To sign transactions, first you need to obtain a public key by making a call to the `ecdsa_public_key` API method.  
+
+<Tabs groupId="language">
+<TabItem value="motoko" label="Motoko" default>
+
+```motoko
+  // Declare "ic" to be the management canister, which is evoked by `actor("aaaaa-aa")`.:
+  let ic : IC = actor("aaaaa-aa");
+
+  public shared (msg) func public_key() : async { #Ok : { public_key: Blob }; #Err : Text } {
+    let caller = Principal.toBlob(msg.caller);
+    
+    try {
+
+      // Make a call to the management canister to request an ECDSA public key:
+      let { public_key } = await ic.ecdsa_public_key({
+          canister_id = null;
+          derivation_path = [ caller ];
+          key_id = { curve = #secp256k1; name = "test_key_1" };
+      });
+      
+      #Ok({ public_key })
+    
+    } catch (err) {
+    
+      #Err(Error.message(err))
+    
+    }
+
+  };
+```
+
+</TabItem>
+
+<TabItem value="rust" label="rust" default>
+
+```rust
+#[update]
+async fn public_key() -> Result<PublicKeyReply, String> {
+    let request = ECDSAPublicKey {
+        canister_id: None,
+        derivation_path: vec![],
+        key_id: EcdsaKeyIds::TestKeyLocalDevelopment.to_key_id(),
+    };
+
+    let (res,): (ECDSAPublicKeyReply,) =
+        ic_cdk::call(mgmt_canister_id(), "ecdsa_public_key", (request,))
+            .await
+            .map_err(|e| format!("ecdsa_public_key failed {}", e.1))?;
+
+    Ok(PublicKeyReply {
+        public_key_hex: hex::encode(&res.public_key),
+    })
+}
+```
+
+</TabItem>
+</Tabs>
+
+## Signing transactions
+
+To sign a transaction, make a call to the `sign_with_ecdsa` API method:
+
+<Tabs groupId="language">
+<TabItem value="motoko" label="Motoko" default>
+
+```motoko
+  public shared (msg) func sign(message_hash: Blob) : async { #Ok : { signature: Blob };  #Err : Text } {
+    assert(message_hash.size() == 32);
+    let caller = Principal.toBlob(msg.caller);
+    try {
+      Cycles.add(10_000_000_000);
+      let { signature } = await ic.sign_with_ecdsa({
+          message_hash;
+          derivation_path = [ caller ];
+          key_id = { curve = #secp256k1; name = "dfx_test_key" };
+      });
+      #Ok({ signature })
+    } catch (err) {
+      #Err(Error.message(err))
+    }
+  };
+```
+
+</TabItem>
+
+<TabItem value="rust" label="rust" default>
+
+```rust
+#[update]
+async fn sign(message: String) -> Result<SignatureReply, String> {
+    let request = SignWithECDSA {
+        message_hash: sha256(&message).to_vec(),
+        derivation_path: vec![],
+        key_id: EcdsaKeyIds::TestKeyLocalDevelopment.to_key_id(),
+    };
+
+    let (response,): (SignWithECDSAReply,) = ic_cdk::api::call::call_with_payment(
+        mgmt_canister_id(),
+        "sign_with_ecdsa",
+        (request,),
+        25_000_000_000,
+    )
+    .await
+    .map_err(|e| format!("sign_with_ecdsa failed {}", e.1))?;
+
+    Ok(SignatureReply {
+        signature_hex: hex::encode(&response.signature),
+    })
+}
+```
+
+</TabItem>
+</Tabs>
+
+## Resources
+
+- [Threshold ECDSA sample dapp - Motoko](https://github.com/dfinity/examples/blob/master/motoko/threshold-ecdsa/).
+
+- [Threshold ECDSA sample dapp - Rust](https://github.com/dfinity/examples/tree/master/rust/threshold-ecdsa).
\ No newline at end of file