# getFeeForMessage

The `getFeeForMessage` RPC method estimates the **base transaction fee** (in lamports) required to process a given **compiled transaction message**. This is especially helpful for displaying cost estimates to users or optimizing fee strategies before submitting transactions.

> **Version Note:** This method is available in `solana-core` v1.9 and above. For older versions, use `getFees`.

***

#### ✅ Common Use Cases

* **Estimate Transaction Fees**\
  Calculate the expected fee for a transaction *before* sending it to the network.
* **Optimize Transaction Costs**\
  Compare fees across different transaction structures or times to identify cost-efficient strategies.
* **Improve User Experience**\
  Show users a real-time fee estimate in your UI before they sign and submit a transaction.

***

#### 🛠 Request Parameters

`getFeeForMessage` takes the following parameters:

* **`message`** (*string, required*):\
  A **base64-encoded** serialized Solana transaction message. Must be a valid compiled message containing instructions, fee payer, and recent blockhash.
* **`config`** (*object, optional*):\
  Configuration object with:
  * `commitment` (*string*):\
    Commitment level (`processed`, `confirmed`, or `finalized`). Defaults to `finalized`.
  * `minContextSlot` (*number*):\
    The minimum slot at which the request is evaluated (for consistency in long-running processes).

***

#### 📦 Response Structure

The `result` field contains:

```json
{
  "context": {
    "slot": <u64>
  },
  "value": <u64 | null>
}
```

* **`context.slot`** – The slot used when evaluating the fee.
* **`value`** – Estimated fee in **lamports** (1 SOL = 1,000,000,000 lamports).\
  `null` if the fee could not be calculated (e.g., expired blockhash or invalid message).

#### 💡 Example: Estimate Fee for a Simple Transfer

> First, compile a transfer transaction and extract its message in base64 format, then call:

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getFeeForMessage",
  "params": [
    "base64_encoded_transaction_message_here",
    {
      "commitment": "finalized"
    }
  ]
}
```

**Code Examples**

{% tabs %}
{% tab title="Nodejs" %}

```javascript
const fetch = require('node-fetch');

async function getFeeForMessage(rpcUrl) {
  try {
    const response = await fetch(rpcUrl, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        jsonrpc: '2.0',
        id: 1,
        method: 'getFeeForMessage',
        "params": [
            "MESSAGE_BASE64_ENCODED", // Replace with your actual base64 encoded message
            { "commitment": "processed" }
          ]
      }),
    });

    const data = await response.json();
    
    // Print the exact full response
    console.log('Full RPC Response:');
    console.log(JSON.stringify(data, null, 2));
    
    return data;
  } catch (error) {
    console.error('Error getting health:', error.message);
    return null;
  }
}

// Example usage
const RPC_URL = 'https://rpc.coinvera.io/?x-api-key=your-coinvera-x-api-key';

getFeeForMessage(RPC_URL);
```

{% endtab %}

{% tab title="Python" %}

```python
import requests
import json

def get_fee_for_message(rpc_url):
    try:
        response = requests.post(
            rpc_url,
            headers={
                'Content-Type': 'application/json',
            },
            json={
                'jsonrpc': '2.0',
                'id': 1,
                'method': 'getFeeForMessage',
                'params': [
                    'MESSAGE_BASE64_ENCODED',  # Replace with your actual base64 encoded message
                    {'commitment': 'processed'}
                ]
            }
        )
        
        data = response.json()
        
        # Print the exact full response
        print('Full RPC Response:')
        print(json.dumps(data, indent=2))
        
        return data
        
    except Exception as error:
        print(f'Error getting health: {error}')
        return None

# Example usage
RPC_URL = 'https://rpc.coinvera.io/?x-api-key=your-coinvera-x-api-key'
get_fee_for_message(RPC_URL)
```

{% endtab %}
{% endtabs %}

**Example Response**

```json
{
  "jsonrpc": "2.0",
  "result": {
    "context": { "slot": 5068 },
    "value": 5000
  },
  "id": 1
}
```

#### 🧠 Developer Tips

* **Message Construction**\
  Ensure your message is well-formed with:
  * Valid fee payer
  * Correct instructions
  * A **recent** blockhash (within \~2 minutes)
* **Expired Blockhash**\
  If the blockhash is too old, the fee may return as `null`. Always refresh the blockhash before compiling the message.
* **Base Fee Only**\
  This method returns **only the base network fee**. To estimate priority fees, use `getRecentPrioritizationFees`.
* **Lamports, Not SOL**\
  The value is returned in **lamports**. Divide by `1_000_000_000` to convert to SOL for display purposes.
* **Handling Null Responses**\
  A `null` fee indicates:
  * Invalid or expired blockhash
  * Malformed message
  * Inability to compute at current commitment level


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.coinvera.io/integration/solana/rpc/getfeeformessage.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.