### Install Mintlify CLI (npm)

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/README.md

Installs the Mintlify command-line interface globally using npm, making the `mintlify` command available system-wide.

```Shell
npm i -g mintlify
```

--------------------------------

### Reinstall Mintlify Dependencies (Shell)

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/README.md

Runs the `mintlify install` command to re-install dependencies, often used for troubleshooting issues like the development server not running.

```Shell
mintlify install
```

--------------------------------

### Python SDK Setup Example

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/api-reference/executions/endpoint/execute-query.mdx

Provides a basic example of setting up the Dune Python SDK client. It shows how to load environment variables and initialize the `DuneClient`.

```python
'''
Download Dune Python SDK by running `pip install dune-client`
For more info, visit the GitHub repository: https://github.com/duneanalytics/dune-client/tree/d2195b2a9577e2dcae5d2600cb3eddce20987f38
'''

import dotenv, os, json
from dune_client.types import QueryParameter
from dune_client.client import DuneClient
from dune_client.query import QueryBase

# change the current working directory where .env file lives
os.chdir("/Users/abc/local-Workspace/python-notebook-examples")
# load .env file
dotenv.load_dotenv(".env")
# setup Dune Python client
dune = DuneClient.from_env()
```

--------------------------------

### Run Mintlify Local Development Server (Shell)

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/README.md

Starts the local development server for previewing documentation changes. This command should be run in the root directory containing the `mint.json` file.

```Shell
mintlify dev
```

--------------------------------

### Add New Page Route in mint.json (JSON)

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/README.md

Example JSON structure to add a new page route to the `routes` array in the `mint.json` configuration file. Defines the URL path and the corresponding MDX component file.

```JSON
{
  "routes": [
    {
      "path": "/new-page",
      "component": "./new-page.mdx"
    }
  ]
}
```

--------------------------------

### Python SDK Setup for Request Example

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/api-reference/executions/endpoint/get-execution-result.mdx

Initializes the Dune Python SDK client by loading environment variables and changing the working directory. This setup is required before making API calls using the SDK, shown here as a prerequisite for subsequent examples.

```python
'''
Download Dune Python SDK by running `pip install dune-client`
For more info, visit the GitHub repository: https://github.com/duneanalytics/dune-client/tree/d2195b2a9577e2dcae5d2600cb3eddce20987f38
'''

import dotenv, os, json
from dune_client.types import QueryParameter
from dune_client.client import DuneClient
from dune_client.query import QueryBase

# change the current working directory where .env file lives
os.chdir("/Users/abc/local-Workspace/python-notebook-examples")
# load .env file
dotenv.load_dotenv(".env")
```

--------------------------------

### Full Example: Dune Client Setup and Querying - Python

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/api-reference/quickstart/results-eg.mdx

A complete example demonstrating how to set up the Dune Python client using environment variables and then how to use the client to either retrieve the latest result of a query without execution or execute the query with parameters and retrieve the fresh result.

```python
import dotenv, os
from dune_client.types import QueryParameter
from dune_client.client import DuneClient
from dune_client.query import QueryBase

# change the current working directory where .env file lives
os.chdir("/Users/abc/project")
# load .env file
dotenv.load_dotenv(".env")
# setup Dune Python client
dune = DuneClient.from_env()

""" get the latest executed result without triggering a new execution """
query_result = dune.get_latest_result(3373921) # get latest result in json format
# query_result = dune.get_latest_result_dataframe(3373921) # get latest result in Pandas dataframe format


"""  query the query (execute and get latest result) """
query = QueryBase(
    query_id=3373921,

    # uncomment and change the parameter values if needed
    # params=[
    #     QueryParameter.text_type(name="contract", value="0x6B175474E89094C44Da98b954EedeAC495271d0F"), # default is DAI
    #     QueryParameter.text_type(name="owner", value="owner"), # default using vitalik.eth's wallet 
    # ],
)

query_result = dune.run_query_dataframe(
  query=query
  # , ping_frequency = 10 # uncomment to change the seconds between checking execution status, default is 1 second
  # , performance="large" # uncomment to run query on large engine, default is medium
  # , batch_size = 5_000 # uncomment to change the maximum number of rows to retrieve per batch of results, default is 32_000
)

# Note: to get the result in csv format, call run_query_csv(); for json format, call run_query().
```

--------------------------------

### Using varbinary_starts_with Example SQL

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/query-engine/Functions-and-operators/varbinary.mdx

Provides a simple example demonstrating how varbinary_starts_with checks if a varbinary begins with a specified prefix. The query returns true if the first argument starts with the second.

```SQL
-- returns true if starts with 0x3d13f874
SELECT varbinary_starts_with(0x3d13f874abcd,0x3d13f874) 
```

--------------------------------

### Install Dune Python SDK

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/api-reference/quickstart/results-eg.mdx

This command installs the Dune Python SDK using pip, the standard package installer for Python.

```bash
pip install dune-client
```

--------------------------------

### Typescript SDK Setup for Execute and Get Result

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/api-reference/executions/endpoint/get-execution-result.mdx

Initializes the Dune Typescript SDK client using the API key from environment variables. This setup is necessary to interact with the Dune API via the SDK.

```typescript
import { QueryParameter, DuneClient } from "@duneanalytics/client-sdk";
const { DUNE_API_KEY } = process.env;
const client = new DuneClient(DUNE_API_KEY ?? "");
```

--------------------------------

### Get Binary Substring from Start (SQL)

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/query-engine/Functions-and-operators/binary.mdx

Returns the rest of binary from the starting position start, measured in bytes. Positions start with 1. A negative starting position is interpreted as being relative to the end of the string.

```SQL
substr(binary, start) → varbinary
```

--------------------------------

### Python SDK Setup for Execute and Get Result

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/api-reference/executions/endpoint/get-execution-result.mdx

Initializes the Dune Python SDK client by loading environment variables and changing the working directory. This setup is required before making API calls using the SDK.

```python
import dotenv, os, json
from dune_client.types import QueryParameter
from dune_client.client import DuneClient
from dune_client.query import QueryBase

# change the current working directory where .env file lives
os.chdir("/Users/abc/local-Workspace/python-notebook-examples")
# load .env file
dotenv.load_dotenv(".env")
# setup Dune Python client
dune = DuneClient.from_env()
```

--------------------------------

### Example config.py file for Dune Client

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/api-reference/quickstart/results-eg.mdx

This is an example of a config.py file structure used to store the Dune API key and request timeout as Python variables.

```python
dune_api_key='<paste your API key here>'
request_timeout=300
```

--------------------------------

### Simple Single http_get Request

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/query-engine/Functions-and-operators/live-fetch.mdx

A basic example demonstrating a single HTTP GET request to fetch data from the CoinGecko API using the `http_get` function.

```sql
SELECT http_get('https://api.coingecko.com/api/v3/coins/list');
```

--------------------------------

### Install Dune API SDK (Bash)

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/learning/how-tos/crypto-pnl-with-dune.mdx

This command installs the necessary Python library, `dune_client`, using pip. This SDK is required to interact with the Dune API from your Python environment.

```bash
pip install dune_client
```

--------------------------------

### Example .env file for Dune Client

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/api-reference/quickstart/results-eg.mdx

This is an example of a .env file structure used to store the Dune API key and request timeout for the Python client.

```dotenv
DUNE_API_KEY=<paste your API key here>
DUNE_API_REQUEST_TIMEOUT=120
```

--------------------------------

### Fetching Dune Execution Results (Go)

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/api-reference/executions/endpoint/get-execution-result-csv.mdx

Provides a Go example for fetching Dune execution results using the standard `net/http` package. It constructs a GET request with the API key header and prints the response status and body.

```Go
package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "https://api.dune.com/api/v1/execution/{execution_id}/results/csv"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("X-DUNE-API-KEY", "<x-dune-api-key>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

--------------------------------

### Input Example for size() Method

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/query-engine/Functions-and-operators/json.mdx

Provides an example sequence of JSON arrays used as input for the size() method demonstration.

```text
[0, 1, 2], ["a", "b", "c", "d"], [null, null]
```

--------------------------------

### Paginating Dune Results using Go

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/api-reference/executions/pagination.mdx

This Go snippet uses the standard `net/http` package to make a GET request to the Dune API. It shows how to add `limit` as a query parameter to the request URL for pagination.

```go
package main

import (
    "fmt"
    "net/http"
    "io/ioutil"
    "net/url"
)

func main() {
    url := "https://api.dune.com/api/v1/query/{query_id}/results"

    // Create query parameters
    params := url.Values{}
    params.Set("limit", "1000")

    // Add parameters to URL
    fullURL := fmt.Sprintf("%s?%s", url, params.Encode())

    req, _ := http.NewRequest("GET", fullURL, nil)

    req.Header.Add("X-DUNE-API-KEY", "<x-dune-api-key>")

    res, _ := http.DefaultClient.Do(req)

    defer res.Body.Close()
    body, _ := ioutil.ReadAll(res.Body)

    fmt.Println(res)
    fmt.Println(string(body))
}
```

--------------------------------

### Input Example for keyvalue() Method

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/query-engine/Functions-and-operators/json.mdx

Provides an example sequence of JSON objects used as input for the keyvalue() method demonstration.

```text
{"customer" : 100, "region" : "AFRICA"},
{"region" : "ASIA"},
{"customer" : 300, "region" : "AFRICA", "comment" : null}
```

--------------------------------

### Simple HTTP GET Request (SQL)

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/query-engine/Functions-and-operators/http.mdx

Basic example of using the `http_get` function to fetch data from a URL, returning the raw response body as a varchar.

```SQL
SELECT http_get('https://api.coingecko.com/api/v3/coins/list');
```

--------------------------------

### Filtering Dune Query Results using Go

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/api-reference/executions/filtering.mdx

Shows how to fetch Dune query results in Go using the standard `net/http` package. It builds the URL with query parameters and sets the API key header before executing the GET request.

```go
package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
	"net/url"
)

func main() {
	url := "https://api.dune.com/api/v1/query/{query_id}/results"

	// Create query parameters
	params := url.Values{}
	params.Set("limit", "10")
	params.Set("filters", "block_time > '2024-03-01'")
	params.Set("columns", "tx_from,tx_to,tx_hash,amount_usd")
	params.Set("sort_by", "amount_usd desc, block_time")

	// Add parameters to URL
	fullURL := fmt.Sprintf("%s?%s", url, params.Encode())
	req, _ := http.NewRequest("GET", fullURL, nil)

	req.Header.Add("X-DUNE-API-KEY", "<x-dune-api-key>")
	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))
}
```

--------------------------------

### Output Example for size() Method

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/query-engine/Functions-and-operators/json.mdx

Shows the resulting sequence of numeric sizes produced by applying the size() method to the input array example.

```text
<path>.size() --> 3, 4, 2
```

--------------------------------

### Install Python SDK

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/api-reference/overview/sdks.mdx

Command to install the official Dune Analytics Python client library using the pip package manager.

```bash
pip install dune-client
```

--------------------------------

### Output Example for keyvalue() Method

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/query-engine/Functions-and-operators/json.mdx

Shows the resulting sequence of key-value-id objects produced by applying the keyvalue() method to the input example.

```text
{"name" : "customer", "value" : 100, "id" : 0},
                      {"name" : "region", "value" : "AFRICA", "id" : 0},
                      {"name" : "region", "value" : "ASIA", "id" : 1},
                      {"name" : "customer", "value" : 300, "id" : 2},
                      {"name" : "region", "value" : "AFRICA", "id" : 2},
                      {"name" : "comment", "value" : null, "id" : 2}
```

--------------------------------

### Install Typescript SDK

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/api-reference/overview/sdks.mdx

Command to install the community-contributed Dune Analytics Typescript client library using the yarn package manager.

```bash
yarn add @duneanalytics/client-sdk
```

--------------------------------

### Rename File and Update Links (Shell)

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/README.md

Uses the `mintlify rename-file` command to rename a documentation file and automatically update all internal links referencing the old file name. This helps prevent broken links after renaming.

```Shell
mintlify rename-file <old-file-name> <new-file-name>
```

--------------------------------

### Check for Broken Links (Shell)

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/README.md

Executes the `mintlify broken-links` command to scan the documentation for broken internal links and output a list to the console. Note that this does not check external `href` links.

```Shell
mintlify broken-links
```

--------------------------------

### Filtering Dune Query Results using Python SDK

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/api-reference/executions/filtering.mdx

Demonstrates fetching the latest results for a specific Dune query using the Python SDK, applying filters, selecting specific columns, and sorting the output. Requires the `dune-client` library and environment setup.

```python
import dotenv, os
from dune_client.types import QueryParameter
from dune_client.client import DuneClient
from dune_client.query import QueryBase

os.chdir("<path_to_your_dotevn_file>")

# load .env file
dotenv.load_dotenv(".env")
# setup Dune Python client
dune = DuneClient.from_env()

query_result = dune.get_latest_result_dataframe(
    query=3567562 # https://dune.com/queries/3567562
    , filters="overtip_amount > 0"
    , columns=["donor_fname","overtip_amount","days_overtipped","overall_tip_given_amount","overall_avg_tip_amount"]
    , sort_by=["overall_tip_given_amount desc"]
)

print(query_result)
```

--------------------------------

### Paginating Dune Results using cURL

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/api-reference/executions/pagination.mdx

This cURL command demonstrates how to make a GET request to the Dune API results endpoint and limit the number of results returned using the `limit` query parameter.

```bash
curl -X GET 'https://api.dune.com/api/v1/query/{{query_id}}/results?limit=1000' -H 'x-dune-api-key: {{api_key}}'
```

--------------------------------

### Get Execution Status using Dune Python SDK

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/api-reference/executions/endpoint/get-execution-status.mdx

This example shows how to use the official Dune Python SDK to fetch the status of a query execution. It requires installing the SDK (`pip install dune-client`), loading environment variables (like the API key), and providing the execution ID (`job_id`).

```python
'''
Download Dune Python SDK by running `pip install dune-client`
For more info, visit the GitHub repository: https://github.com/duneanalytics/dune-client/tree/d2195b2a9577e2dcae5d2600cb3eddce20987f38
'''

import dotenv, os, json
from dune_client.types import QueryParameter
from dune_client.client import DuneClient
from dune_client.query import QueryBase

# change the current working directory where .env file lives
os.chdir("/Users/abc/local-Workspace/python-notebook-examples")
# load .env file
dotenv.load_dotenv(".env")
# setup Dune Python client
dune = DuneClient.from_env()

result = dune.get_execution_status(job_id = '01HM79YYNXADPK66YWZK5X0NXB') # pass in the execution_id
```

--------------------------------

### Using SQL Quantifiers ALL, ANY, SOME

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/query-engine/Functions-and-operators/comparison.mdx

Demonstrates the usage of ALL, ANY, and SOME quantifiers with comparison operators in SQL queries. Shows examples returning true and false based on subquery results.

```sql
SELECT 'hello' = ANY (VALUES 'hello', 'world'); -- true

SELECT 21 < ALL (VALUES 19, 20, 21); -- false

SELECT 42 >= SOME (SELECT 41 UNION ALL SELECT 42 UNION ALL SELECT 43); -- true
```

--------------------------------

### Paginating Dune Results using Java Unirest

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/api-reference/executions/pagination.mdx

This Java snippet uses the Unirest library to perform a GET request to the Dune API. It shows how to easily add `limit` and `offset` as query string parameters for pagination.

```java
import kong.unirest.HttpResponse;
import kong.unirest.Unirest;

public class Main {
    public static void main(String[] args) {
        HttpResponse<String> response = Unirest.get("https://api.dune.com/api/v1/query/{query_id}/results")
                    .header("X-DUNE-API-KEY", "<x-dune-api-key>")
                    .queryString("limit", 1000)
                    .queryString("offset", 0)
                    .asString();

            System.out.println(response.getBody());
        }
    }

```

--------------------------------

### Set up Dune Python Client (Inline)

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/api-reference/quickstart/results-eg.mdx

Initialize the DuneClient by providing your API key directly. You can also configure the base URL and request timeout.

```python
dune = DuneClient(
    api_key='<paste your api key here>',
    base_url="https://api.dune.com",
    request_timeout=300 # request will time out after 300 seconds
)
```

--------------------------------

### SQL LIKE with Percent Wildcard

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/query-engine/Functions-and-operators/comparison.mdx

Demonstrates using the LIKE operator with the % wildcard in SQL to find strings that start with a specific character sequence. Filters a list of continents to find those starting with 'E'.

```sql
SELECT * FROM (VALUES 'America', 'Asia', 'Africa', 'Europe', 'Australia', 'Antarctica') AS t (continent)
    WHERE continent LIKE 'E%';
```

--------------------------------

### Set up Dune Python Client (using .py file)

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/api-reference/quickstart/results-eg.mdx

Initialize the DuneClient by importing configuration variables from a separate Python file (e.g., config.py). This helps organize configuration settings.

```python
import config

dune = DuneClient(
    api_key=config.dune_api_key,
    base_url="https://api.dune.com",
    request_timeout=(config.request_timeout)
)
```

--------------------------------

### Example Parameterized Dune Embed URL

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/web-app/embeds.mdx

This snippet provides a working example of a Dune embed URL that includes parameters. Parameters must be manually appended to the base embed link using the format '?param1=value1&param2=value2'.

```url
https://dune.com/embeds/118220/238460/aa002dd3-f9e2-4d63-86c8-b765569306c6NFT?address=0xff9c1b15b16263c61d017ee9f65c50e4ae0113d7&rolling_n_trades=500
```

--------------------------------

### Embedding an Arcade Software Demo in HTML

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/quickstart.mdx

This HTML snippet demonstrates how to embed an interactive demo from Arcade Software using an iframe within a styled div container. The styling ensures the iframe maintains a responsive aspect ratio.

```HTML
<div
  style={{
    position: "relative",
    paddingBottom: "calc(66.66666666666666% + 41px)",
    height: 0
  }}
>
  <iframe
    src="https://demo.arcade.software/xTAXmlo0nCL0FOn38hW9?embed"
    frameBorder={0}
    loading="lazy"
    webkitallowfullscreen=""
    mozallowfullscreen=""
    allowFullScreen=""
    style={{
      position: "absolute",
      top: 0,
      left: 0,
      width: "100%",
      height: "100%",
      colorScheme: "light"
    }}
    title="Creating a dashboard"
  />
</div>
```

--------------------------------

### Get Binary Substring with Length (SQL)

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/query-engine/Functions-and-operators/binary.mdx

Returns a substring from binary of length length from the starting position start, measured in bytes. Positions start with 1. A negative starting position is interpreted as being relative to the end of the string.

```SQL
substr(binary, start, length) → varbinary
```

--------------------------------

### Set up Dune Python Client (using .env file)

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/api-reference/quickstart/results-eg.mdx

Initialize the DuneClient by loading the API key and other configuration from a .env file. This is a common practice for managing secrets.

```python
import dotenv, os

# change the current working directory where .env file lives
os.chdir("/Users/abc/project")
# load .env file
dotenv.load_dotenv(".env")
# setup Dune Python client
dune = DuneClient.from_env()
```

--------------------------------

### Reduce Aggregation Product Example (SQL)

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/query-engine/Functions-and-operators/aggregate.mdx

Example demonstrating the use of reduce_agg to calculate the product of values grouped by an ID. It initializes the state to 1 and uses multiplication for both input and combine functions.

```sql
SELECT id, reduce_agg(value, 1, (a, b) -> a * b, (a, b) -> a * b)
FROM (
    VALUES
        (1, 3),
        (1, 4),
        (1, 5),
        (2, 6),
        (2, 7)
) AS t(id, value)
GROUP BY id;
```

--------------------------------

### Example Source Table Data (Text)

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/query-engine/Functions-and-operators/conditional.mdx

Shows sample data from the 'shipping' table used in the TRY examples, illustrating the presence of invalid data ('P332a') and a zero value in the 'packages' column.

```text
origin_state | origin_zip | packages | total_cost
--------------+------------+----------+------------
California   |      94131 |       25 |        100
California   |      P332a |        5 |         72
California   |      94025 |        0 |        155
New Jersey   |      08544 |      225 |        490
(4 rows)
```

--------------------------------

### Example Webhook Alert Payload (JSON)

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/web-app/alerts.mdx

Provides a concrete example of the JSON payload sent via webhook, showing typical data for a query execution and associated visualizations.

```JSON
{
  "message": "Query ETH SMA alert was submitted for execution at Wed, 13 Dec 2023 13:42:40 GMT by your query schedule and it was successfully executed with a non-empty result.\nYou can check its latest result here: https://dune.com/queries/3137182?utm_source=webhook&utm_campaign=alerts",
  "query_result": {
    "execution_id": "01HHHPMKG6NBY0B04A36TS3AQH",
    "query_id": 3137182,
    "state": "QUERY_STATE_COMPLETED",
    "submitted_at": "2023-12-13T13:42:40Z",
    "expires_at": "2024-03-12T13:42:48Z",
    "execution_started_at": "2023-12-13T13:42:40Z",
    "execution_ended_at": "2023-12-13T13:42:48Z",
    "result": {
      "data_uri": "https://api.dune.com/api-referencev1/execution/01HHHPMKG6NBY0B04A36TS3AQH/results",
      "metadata": {
        "column_names": [
          "day",
          "avg_price",
          "sma_20",
          "sma_50",
          "sma_100",
          "sma_200"
        ],
        "result_set_bytes": 10710,
        "total_row_count": 91,
        "datapoint_count": 546,
        "pending_time_millis": 13,
        "execution_time_millis": 8038
      }
    }
  },
  "visualizations": [
    {
      "title": "SMA",
      "image_url": "https://prod-dune-media.s3.eu-west-1.amazonaws.com/screenshots/3137182/01HHHPMKG6NBY0B04A36TS3AQH/5232261.png"
    },
    {
      "title": "Counter",
      "image_url": "https://prod-dune-media.s3.eu-west-1.amazonaws.com/screenshots/3137182/01HHHPMKG6NBY0B04A36TS3AQH/5451006.png"
    },
    {
      "title": "Last days of data",
      "image_url": "https://prod-dune-media.s3.eu-west-1.amazonaws.com/screenshots/3137182/01HHHPMKG6NBY0B04A36TS3AQH/5451008.png"
    }
  ]
}
```

--------------------------------

### Get Execution Status using PHP cURL

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/api-reference/executions/endpoint/get-execution-status.mdx

This PHP example uses the cURL extension to make a GET request to the execution status endpoint. It configures the URL, sets the `X-DUNE-API-KEY` header, and handles the response.

```php
<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.dune.com/api/v1/execution/{execution_id}/status",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "X-DUNE-API-KEY: <x-dune-api-key>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

?>
```

--------------------------------

### Get Execution Status using Python Requests

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/api-reference/executions/endpoint/get-execution-status.mdx

This snippet uses the popular Python `requests` library to perform a GET request to the status endpoint. It requires installing `requests` and setting the `X-DUNE-API-KEY` header with your API key.

```python
import requests

url = "https://api.dune.com/api/v1/execution/{execution_id}/status"

headers = {"X-DUNE-API-KEY": "<x-dune-api-key>"}

response = requests.request("GET", url, headers=headers)

print(response.text)
```

--------------------------------

### CASE Equivalent of IF Example (SQL)

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/query-engine/Functions-and-operators/conditional.mdx

Shows an equivalent SQL query using a CASE expression to achieve the same categorization of orders based on total price as the IF example.

```sql
SELECT
  orderkey,
  totalprice,
  CASE
    WHEN totalprice >= 150000 THEN 'High Value'
    ELSE 'Low Value'
  END
FROM tpch.sf1.orders;
```

--------------------------------

### Using varbinary_substring (Suffix) SQL

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/query-engine/Functions-and-operators/varbinary.mdx

Demonstrates extracting a suffix from a varbinary starting at a specified index. The example retrieves a portion of a byte array starting from the 21st byte.

```SQL
-- using varbinary_substring starting from the 21th index
-- this returns 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 
SELECT 0x0000000000000000000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 as original_bytearray,
       varbinary_substring(0x0000000000000000000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2,21) as bytearraysubstring_data
```

--------------------------------

### Querying Daily DEX Volume and Count with Project Filter - DuneSQL

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/learning/how-tos/create-your-first-query.mdx

This query extends the previous one by including the `project` column and adding a WHERE clause to filter results by a specific project name using a parameter `{{Project Name}}`. It groups by date, blockchain, and project, and orders by date descending and volume descending.

```SQL
SELECT
  block_date,
  blockchain,
  project,
  COUNT(*) as number_of_trades,
  SUM(amount_usd) as trading_volume_usd
FROM dex.trades
WHERE
  block_date >= NOW() - INTERVAL '30' day
  AND project = '{{Project Name}}' -- Try 'uniswap' or 'curve'
GROUP BY
  1, 2, 3
ORDER BY
  1 DESC, 5 DESC
```

--------------------------------

### Querying Ethereum Daily Activity with SQL

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/quickstart.mdx

This SQL query analyzes the `ethereum.transactions` table to find the number of unique daily active users (addresses sending transactions) and receiving addresses (addresses receiving transactions) on Ethereum for the year 2023. It truncates the `block_time` to the day and groups the results by day.

```SQL
--Query to get Ethereum's unique daily active users and passive users  in 2023

SELECT  
--truncate time to day
date_trunc('day', block_time) AS time,
-- count distinct addresses that sent a transactions
COUNT(distinct "from") AS users,
-- count distinct addresses that received a transaction
COUNT(distinct "to") AS receiving_addresses
FROM ethereum.transactions
WHERE block_time > DATE '2023-01-01'
GROUP BY time
```

--------------------------------

### Get Dune Execution Results using Java Unirest

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/api-reference/executions/endpoint/get-execution-result.mdx

Shows a concise Java example using the Unirest library to perform a GET request to the Dune API results endpoint. It includes setting the API key header and retrieving the response as a string.

```java
HttpResponse<String> response = Unirest.get("https://api.dune.com/api/v1/execution/{execution_id}/results")
  .header("X-DUNE-API-KEY", "<x-dune-api-key>")
  .asString();
```

--------------------------------

### Execute Query and Get Result with Python SDK

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/api-reference/executions/endpoint/get-execution-result-csv.mdx

Demonstrates initializing the Dune Python SDK client and executing a query to fetch results in a single workflow. It shows loading environment variables and using the `run_query` method.

```python
import dotenv, os, json
from dune_client.types import QueryParameter
from dune_client.client import DuneClient
from dune_client.query import QueryBase

# change the current working directory where .env file lives
os.chdir("/Users/abc/local-Workspace/python-notebook-examples")
# load .env file
dotenv.load_dotenv(".env")
# setup Dune Python client
dune = DuneClient.from_env()
```

```python
result = dune.run_query(
 query=query # pass in query to run 
 , performance = 'large' # optionally define which tier to run the execution on (default is "medium")
 )
```

--------------------------------

### Output of soundex() SQL Example

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/query-engine/Functions-and-operators/string.mdx

Shows the expected output from the SQL query using the SOUNDEX function, illustrating that 'CHINA' is matched with 'CHYNA' phonetically.

```text
     name  |
    -------+----
     CHINA |
    (1 row)
```

--------------------------------

### Executing Dune Query via API - Go

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/api-reference/executions/endpoint/execute-query.mdx

This Go example demonstrates how to make a POST request to the Dune API using the standard net/http package. It shows how to create a new request, add the 'X-DUNE-API-KEY' header, execute the request using the default client, and read the response body.

```Go
package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "https://api.dune.com/api/v1/query/{query_id}/execute"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("X-DUNE-API-KEY", "<x-dune-api-key>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

--------------------------------

### Using varbinary_substring (Length) Example SQL

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/query-engine/Functions-and-operators/varbinary.mdx

Provides a simple example of extracting a sub-varbinary of a specified length from a given varbinary. The query extracts 3 bytes starting from index 1.

```SQL
-- returns  0xabcdef
SELECT 0xabcdefabcdef as varbinary_data,
       varbinary_substring(0xabcdefabcdef,1,3) as varbinary_substring
```

--------------------------------

### Reduce Aggregation Sum Example (SQL)

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/query-engine/Functions-and-operators/aggregate.mdx

Example demonstrating the use of reduce_agg to sum values grouped by an ID. It initializes the state to 0 and uses addition for both input and combine functions.

```sql
SELECT id, reduce_agg(value, 0, (a, b) -> a + b, (a, b) -> a + b)
FROM (
    VALUES
        (1, 3),
        (1, 4),
        (1, 5),
        (2, 6),
        (2, 7)
) AS t(id, value)
GROUP BY id;
```

--------------------------------

### Get Length of Varchar - Dune SQL - SQL

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/query-engine/Functions-and-operators/varbinary.mdx

Returns the length in characters of a string (varchar) value as a bigint. The example shows how to get the length of a string and check its data type.

```SQL
-- this will return 20
SELECT typeof('0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2') as data_type,
       varbinary_length('0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2') varchar_length
```

--------------------------------

### Create Table using cURL

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/api-reference/tables/endpoint/create.mdx

Example using cURL to send a POST request to the /v1/table/create endpoint with the required JSON payload for creating a table.

```bash
curl --request POST \
  --url https://api.dune.com/api/v1/table/create \
  --header 'X-DUNE-API-KEY: <x-dune-api-key>' \
  --header 'Content-Type: application/json' \
  --data '{
  "namespace":"my_user",
  "table_name":"interest_rates",
  "description": "10 year daily interest rates, sourced from https://fred.stlouisfed.org/series/DGS10",
  "is_private": false,
  "schema": [{"name": "date", "type": "timestamp"}, {"name": "dgs10", "type": "double",  "nullable": true}]
}'
```

--------------------------------

### Querying Daily DEX Volume and Count - DuneSQL

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/learning/how-tos/create-your-first-query.mdx

This query selects the block date, blockchain, counts the number of trades, and sums the trading volume in USD from the `dex.trades` table. It filters for data within the last 30 days, groups results by date and blockchain, and orders by date descending and volume descending.

```SQL
SELECT
  block_date,
  blockchain,
  COUNT(*) as number_of_trades,
  SUM(amount_usd) as trading_volume_usd
FROM dex.trades
WHERE
  block_date >= NOW() - INTERVAL '30' day
GROUP BY
  1, 2
ORDER BY
  1 DESC, 4 DESC
```

--------------------------------

### Get Dune Execution Results using PHP cURL

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/api-reference/executions/endpoint/get-execution-result.mdx

Provides a PHP example using the cURL library to make a GET request to the Dune API results endpoint. It sets the URL, request method, and the required API key header, then executes the request and handles potential errors.

```php
<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.dune.com/api/v1/execution/{execution_id}/results",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "X-DUNE-API-KEY: <x-dune-api-key>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

?>
```

--------------------------------

### Get Cardinality of Set Digest - Trino SQL

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/query-engine/Functions-and-operators/setdigest.mdx

Demonstrates how to use the `cardinality` function to get the estimated number of distinct elements from a set digest created using `make_set_digest`. The example shows the expected output.

```SQL
SELECT cardinality(make_set_digest(value))
    FROM (VALUES 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5) T(value);
    -- 5
```

--------------------------------

### Initialize Dune Client (Python)

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/learning/how-tos/crypto-pnl-with-dune.mdx

This Python code initializes the `DuneClient` object. You must replace the placeholder with your actual Dune API key. The base URL and a request timeout are also configured.

```python
dune_api_key = 'your_api_key_here'
dune = DuneClient(api_key=dune_api_key, base_url="https://api.dune.com", request_timeout=300)
```

--------------------------------

### Get Execution Status using Javascript Fetch

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/api-reference/executions/endpoint/get-execution-status.mdx

This example demonstrates fetching the execution status using the browser's built-in `fetch` API in Javascript. It requires setting the `X-DUNE-API-KEY` header in the request options.

```javascript
const options = {method: 'GET', headers: {'X-DUNE-API-KEY': '<x-dune-api-key>'}};

fetch('https://api.dune.com/api/v1/execution/{execution_id}/status', options)
  .then(response => response.json())
  .then(response => console.log(response))
  .catch(err => console.error(err));
```

--------------------------------

### Import TableSample Component (JavaScript)

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/data-catalog/stellar/history_trades.mdx

Imports the `TableSample` component from the specified local path. This component is intended for rendering database tables within the MDX content.

```JavaScript
import { TableSample } from "/snippets/table-sample.mdx";
```

--------------------------------

### Using http_get with API Key Placeholder

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/query-engine/Functions-and-operators/live-fetch.mdx

Shows how to use `http_get` with a query parameter placeholder (`{{api_key}}`) which can be replaced by Dune's query parameter feature, useful for handling credentials without hardcoding.

```sql
SELECT http_get(
    'https://api.blastscan.io/api?module=block&action=getblocknobytime&timestamp=1711712564&closest=before&apikey={{api_key}}'
);
```

--------------------------------

### Fetch Execution Results via cURL

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/api-reference/executions/endpoint/get-execution-result-csv.mdx

Provides a cURL command example to directly retrieve the CSV results of a completed query execution using the Dune API GET endpoint. Requires the execution ID and API key.

```bash
curl -X GET "https://api.dune.com/api/v1/execution/{{execution_id}}/results/csv" -H x-dune-api-key:{{api_key}}
```

--------------------------------

### Lambda Expression Syntax Examples

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/query-engine/Functions-and-operators/lambda.mdx

Illustrates basic syntax forms for lambda expressions in SQL contexts, showing single/multiple arguments and various expressions within the body.

```text
    x -> x + 1
    (x, y) -> x + y
    x -> regexp_like(x, 'a+')
    x -> x[1] / x[2]
    x -> IF(x > 0, x, -x)
    x -> COALESCE(x, 0)
    x -> CAST(x AS JSON)
    x -> x + TRY(1 / 0)
```

--------------------------------

### Importing MDX Components

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/data-catalog/evm/flare/decoded/overview.mdx

Imports necessary components, OverviewDecodedDataApproach and DuneEmbed, from their respective file paths for use within the MDX page.

```MDX
import { OverviewDecodedDataApproach } from "/snippets/evm/decoded/decoded-overview-snippet.mdx"
import { DuneEmbed } from '/snippets/dune-embed.mdx'
```

--------------------------------

### Using varbinary_position with Varchar SQL

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/query-engine/Functions-and-operators/varbinary.mdx

Shows how to use varbinary_position to find the starting index of a substring within a string. The example searches for '0x6cc2' within a hexadecimal string representation.

```SQL
-- search for '0x6cc2' and return its position
SELECT varbinary_position('0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2','0x6cc2') 
```

--------------------------------

### Importing Table Sample Component (MDX)

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/data-catalog/evm/beacon/attestations.mdx

Imports the TableSample component from a local MDX file to display a sample of the table data.

```javascript
import { TableSample } from "/snippets/table-sample.mdx";
```

--------------------------------

### Get Length of Varbinary - Dune SQL - SQL

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/query-engine/Functions-and-operators/varbinary.mdx

Returns the length in bytes of a varbinary value as a bigint. The example shows that a 20-byte varbinary value returns a length of 20.

```SQL
-- this will return 20
SELECT varbinary_length(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2)
```

--------------------------------

### Using TableSample Component (MDX)

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/data-catalog/evm/beacon/epoch-summaries.mdx

Renders the `TableSample` component, passing the schema and table name as props. This component fetches and displays a sample of the specified table, `beacon.epoch_summaries` in this case.

```MDX
<TableSample tableSchema="beacon" tableName="epoch_summaries" />
```

--------------------------------

### Fetch Private Dune Query Results

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/api-reference/queries/endpoint/private.mdx

These examples demonstrate how to retrieve results for a private Dune query using its ID via the API. A valid API key is required in the 'X-DUNE-API-KEY' header, and access requires a Dune Plus plan or higher. The examples show how to make a GET request to the `/v1/query/{queryId}/private` endpoint.

```bash
curl --request GET \
  --url https://api.dune.com/api/v1/query/{queryId}/private \
  --header 'X-DUNE-API-KEY: <x-dune-api-key>'
```

```python
import dotenv, os
from dune_client.client import DuneClient

dotenv_path = os.path.join(os.path.dirname(__file__), '..', '.env')
dotenv.load_dotenv(".env")
dune = DuneClient.from_env()

query = dune.private_query(1252207)
```

```python
import requests

url = "https://api.dune.com/api/v1/query/{queryId}/private"

headers = {"X-DUNE-API-KEY": "<x-dune-api-key>"}

response = requests.request("GET", url, headers=headers)

print(response.text)
```

```javascript
const options = {method: 'GET', headers: {'X-DUNE-API-KEY': '<x-dune-api-key>'}};

fetch('https://api.dune.com/api/v1/query/{queryId}/private', options)
  .then(response => response.json())
  .then(response => console.log(response))
  .catch(err => console.error(err));
```

```go
package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "https://api.dune.com/api/v1/query/{queryId}/private"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("X-DUNE-API-KEY", "<x-dune-api-key>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```php
<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.dune.com/api/v1/query/{queryId}/private",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "X-DUNE-API-KEY: <x-dune-api-key>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
```

```java
HttpResponse<String> response = Unirest.get("https://api.dune.com/api/v1/query/{queryId}/private")
  .header("X-DUNE-API-KEY", "<x-dune-api-key>")
  .asString();
```

--------------------------------

### Importing Table Sample Component (MDX)

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/data-catalog/fuel/blocks.mdx

Imports the TableSample MDX component from a local path (/snippets/table-sample.mdx) to make it available for use within the current document.

```MDX
import { TableSample } from "/snippets/table-sample.mdx";
```

--------------------------------

### Unprivating Query with Java Unirest

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/api-reference/queries/endpoint/unprivate.mdx

Provides a Java example using the Unirest library to unprivate a Dune query. It makes a GET request to the specified URL, adds the API key header, and retrieves the response as a string.

```java
HttpResponse<String> response = Unirest.get("https://api.dune.com/api/v1/query/{queryId}/unprivate")
  .header("X-DUNE-API-KEY", "<x-dune-api-key>")
  .asString();
```

--------------------------------

### Transforming Numeric Keys using Map Lookup with transform_keys() in SQL

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/query-engine/Functions-and-operators/map.mdx

This example shows a more complex key transformation using `transform_keys`. It transforms numeric keys by looking them up in another map to get the new key value.

```SQL
SELECT transform_keys(MAP(ARRAY [1, 2], ARRAY [1.0, 1.4]), (k, v) -> MAP(ARRAY[1, 2], ARRAY['one', 'two'])[k]);
-- {one -> 1.0, two -> 1.4}
```

--------------------------------

### Create Table using Python SDK

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/api-reference/tables/endpoint/create.mdx

Example using the Dune Python SDK to create a table by calling the create_table method with the specified namespace, table name, description, schema, and privacy setting.

```python
import dotenv, os
from dune_client.client import DuneClient

dotenv_path = os.path.join(os.path.dirname(__file__), '.', '.env')
dotenv.load_dotenv(".env")
dune = DuneClient.from_env()

table = dune.create_table(
        namespace="my_user",
        table_name="interest_rates",
        description="10 year daily interest rates, sourced from https://fred.stlouisfed.org/series/DGS10",
        schema= [
            {"name": "date", "type": "timestamp"},
            {"name": "dgs10", "type": "double", "nullable": True}
        ],
        is_private=False
)
```

--------------------------------

### Displaying Table Sample (MDX)

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/data-catalog/evm/beacon/attestations.mdx

Uses the imported TableSample component to render a sample of the 'attestations' table from the 'beacon' schema.

```mdx
<TableSample tableSchema="beacon" tableName="attestations" />
```

--------------------------------

### JSONPath Item Methods ceiling(), floor(), abs()

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/query-engine/Functions-and-operators/json.mdx

Describes the `.ceiling()`, `.floor()`, and `.abs()` item methods for getting the ceiling, floor, or absolute value of numeric items in a sequence. Includes syntax for each and a combined example.

```text
<path>.ceiling()
```

```text
<path>.floor()
```

```text
<path>.abs()
```

```text
-1.5, -1, 1.3
```

```text
<path>.ceiling() --> -1.0, -1, 2.0
```

```text
<path>.floor() --> -2.0, -1, 1.0
```

```text
<path>.abs() --> 1.5, 1, 1.3
```

--------------------------------

### Unprivating Query with JavaScript Fetch

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/api-reference/queries/endpoint/unprivate.mdx

Provides a JavaScript example using the Fetch API to unprivate a Dune query. It sets up the request options with the GET method and API key header, then fetches the data and logs the JSON response.

```javascript
const options = {method: 'GET', headers: {'X-DUNE-API-KEY': '<x-dune-api-key>'}};

fetch('https://api.dune.com/api/v1/query/{queryId}/unprivate', options)
  .then(response => response.json())
  .then(response => console.log(response))
  .catch(err => console.error(err));
```

--------------------------------

### Unarchiving Dune Query using JavaScript Fetch

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/api-reference/queries/endpoint/unarchive.mdx

This JavaScript example uses the Fetch API to unarchive a Dune query. It sets the HTTP method to GET and includes the API key in the headers before making the request.

```javascript
const options = {method: 'GET', headers: {'X-DUNE-API-KEY': '<x-dune-api-key>'}};

fetch('https://api.dune.com/api/v1/query/{queryId}/unarchive', options)
  .then(response => response.json())
  .then(response => console.log(response))
  .catch(err => console.error(err));
```

--------------------------------

### Using OverviewDecodedDataApproach Component

Source: https://github.com/vy-bewhale/dune/blob/main/dune-docs/data-catalog/evm/flare/decoded/overview.mdx

Renders the imported OverviewDecodedDataApproach component, passing the 'blockchain' property with the value 'flare' to configure its behavior.

```MDX
<OverviewDecodedDataApproach blockchain= "flare"/>
```