Dune

https://docs.dune.com/
Admin
Dune is an onchain data platform that provides infrastructure, data, and tools to make crypto data...
Tokens:951,982
Snippets:9,060
Trust Score:9.9
Update:5 hours ago
Show doc for...
Tokens:
Raw
### Putting it all together

Source: https://docs.dune.com/api-reference/quickstart/results-eg

Complete example combining client setup, getting latest result, and executing a query with optional parameters.

```python
from dune_client.client import DuneClient
from dune_client.query import QueryBase

# setup Dune Python client
dune = DuneClient()

# get the latest executed result without triggering a new execution
query_result = dune.get_latest_result(3373921) # get latest result in json 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
) 
```

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

### Install Dune Go SDK

Source: https://docs.dune.com/api-reference/overview/introduction

Install the duneapi-client-go package via go get to use the Go SDK.

```bash
go get github.com/duneanalytics/duneapi-client-go
```

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

### Test Your Connection with dbt Commands

Source: https://docs.dune.com/api-reference/connectors/dbt/getting-started

Run these commands to install dependencies, test the connection, run your first model, and run tests. Requires `uv` and a configured dbt project.

```bash
# Install dbt dependencies
uv run dbt deps

# Test connection
uv run dbt debug

# Run your first model
uv run dbt run

# Run tests
uv run dbt test
```

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

### Install Dune TypeScript SDK

Source: https://docs.dune.com/api-reference/overview/introduction

Install the @duneanalytics/client package via npm to use the TypeScript SDK.

```bash
npm install @duneanalytics/client
```

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

### Initialize Dune SDK (Python, TypeScript, Go)

Source: https://docs.dune.com/api-reference/overview/getting-started

Initialize the Dune client in Python, TypeScript, or Go. The SDKs read the DUNE_API_KEY environment variable for security.

```python
from dune_client import DuneClient

# DuneClient will read the DUNE_API_KEY environment variable
dune = DuneClient()
```

```typescript
import { DuneClient } from '@duneanalytics/client-sdk';

// Use environment variable for security
const dune = new DuneClient(process.env.DUNE_API_KEY);
```

```go
import "github.com/duneanalytics/duneapi-client-go"
import "os"

// Use environment variable for security
client := duneapi.New(os.Getenv("DUNE_API_KEY"))
```

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

### Clone and set up the dbt template repository

Source: https://docs.dune.com/api-reference/connectors/dbt/getting-started

Commands to clone the dbt template repository, navigate into it, and install dependencies with uv. The template includes pre-configured profiles, sample models, and CI/CD workflows; CI workflows are disabled by default to avoid consuming Dune credits.

```bash
# Create a new repository from the template
# (Use GitHub's "Use this template" button)

# Clone your new repository
git clone https://github.com/your-org/your-dbt-project.git
cd your-dbt-project

# Install dependencies
uv sync

# Set up environment variables (see next section)
```

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

### Execute SQL query with Python SDK

Source: https://docs.dune.com/api-reference/overview/getting-started

Execute a SQL query using the Dune Python SDK. Replace YOUR_API_KEY with your actual key.

```python
from dune_client import DuneClient

dune = DuneClient(api_key="YOUR_API_KEY")

# Execute a SQL query
sql = """
SELECT * FROM dex.trades 
WHERE block_time > now() - interval '1' day 
LIMIT 10
"""

results = dune.run_sql(query_sql=sql)
print(results.get_rows())
```

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

### Authenticate with X-DUNE-API-KEY header

Source: https://docs.dune.com/api-reference/overview/getting-started

Include your API key in the request header to authenticate with Dune's APIs. Replace 'your-api-key-here' with your actual key.

```http
X-DUNE-API-KEY: your-api-key-here
```

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

### Go GET query pipeline with net/http

Source: https://docs.dune.com/api-reference/queries/endpoint/get-query-pipeline

Uses Go's net/http package to send a GET request with the API key header and prints the response body. Ignores errors for brevity.

```go
package main

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

func main() {

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

	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, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}
```

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

### Quick Start: Initialize client and execute query

Source: https://docs.dune.com/api-reference/overview/sdks

Initialize the Dune client with an API key from the DUNE_API_KEY environment variable and execute a query by ID.

```go
package main

import (
    "fmt"
    "os"
    
    "github.com/duneanalytics/duneapi-client-go"
)

func main() {
    // Initialize client
    client := duneapi.New(os.Getenv("DUNE_API_KEY"))
    
    // Execute a query
    results, err := client.Execute(3493826)
    if err != nil {
        panic(err)
    }
    
    fmt.Printf("Got %d rows\n", len(results.Rows))
}
```

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

### Execute SQL query with cURL

Source: https://docs.dune.com/api-reference/overview/getting-started

Execute a SQL query to get recent DEX trades using cURL. Replace YOUR_API_KEY with your actual key.

```bash
# Execute a SQL query
curl -X POST "https://api.dune.com/api/v1/sql/execute" \
  -H "Content-Type: application/json" \
  -H "X-DUNE-API-KEY: YOUR_API_KEY" \
  -d '{
    "sql": "SELECT * FROM dex.trades WHERE block_time > now() - interval '\''1'\'' day LIMIT 10",
    "performance": "medium"
  }'
```

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

### Execute saved query with TypeScript SDK

Source: https://docs.dune.com/api-reference/overview/getting-started

Execute a saved query using the Dune TypeScript SDK. Replace YOUR_API_KEY with your actual key.

```typescript
import { DuneClient } from '@duneanalytics/client-sdk';

const dune = new DuneClient('YOUR_API_KEY');

// Execute a saved query
const executionResult = await dune.runQuery({ queryId: 3493826 });
console.log(executionResult.result?.rows);
```

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

### Quick Start: Execute a query and print rows

Source: https://docs.dune.com/api-reference/overview/sdks

Initialize DuneClient (reads DUNE_API_KEY environment variable), execute a query by ID or raw SQL, and iterate over result rows.

```python
from dune_client import DuneClient

# DuneClient will read the DUNE_API_KEY environment variable
dune = DuneClient()

# Execute a query by ID
results = dune.execute(query_id=3493826)

# Or execute raw SQL
results = dune.execute(sql="SELECT * FROM dex.trades LIMIT 10")

# Access results
for row in results.rows:
    print(row)
```

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

### Set up Dune Python client

Source: https://docs.dune.com/api-reference/quickstart/results-eg

Initialize a DuneClient with an API key, base URL, and request timeout. The API key can also be read from environment variables DUNE_API_KEY, DUNE_API_BASE_URL, and DUNE_API_REQUEST_TIMEOUT.

```python
from dune_client.client import DuneClient

dune = DuneClient(
    api_key='<paste your api key here>',
    base_url="https://api.dune.com",
    request_timeout=300
)
```

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

### Quick Start: Initialize DuneClient and execute a query

Source: https://docs.dune.com/api-reference/overview/sdks

Initialize the DuneClient with your API key from the DUNE_API_KEY environment variable, execute a saved query by ID, and log the returned rows. Requires the @duneanalytics/client-sdk package.

```typescript
import { DuneClient, QueryParameter } from '@duneanalytics/client-sdk';

// Initialize client
const dune = new DuneClient(process.env.DUNE_API_KEY!);

// Execute a query
const results = await dune.execute({ queryId: 3493826 });

// Access results
console.log(`Got ${results.rows.length} rows`);
results.rows.forEach(row => console.log(row));
```

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

### Python SDK download_csv example

Source: https://docs.dune.com/api-reference/executions/endpoint/get-query-result-csv

Uses the Dune Python SDK to download query results as CSV. Requires installing the dune-client package via pip. The example passes query_id '2363421' and also mentions the get_latest_result_dataframe method for Pandas DataFrame output.

```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 json
from dune_client.types import QueryParameter
from dune_client.client import DuneClient
from dune_client.query import QueryBase

# setup Dune Python client
dune = DuneClient()

# pass in the query_id
result = dune.download_csv('2363421') 

# can also call `get_latest_result_dataframe` method to get latest result in Python Pandas dataframe format
```

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

### Execute query with Go SDK

Source: https://docs.dune.com/api-reference/overview/introduction

Initialize a new Dune client and call Execute to run a query and get results. The execute() function handles polling and pagination automatically.

```go
client := duneapi.New("your-key")
results := client.Execute(3493826)
```

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

### Create Query with Python SDK

Source: https://docs.dune.com/api-reference/queries/endpoint/create

Python example using dune_client to create a query. Requires X-DUNE-API-KEY with Read/Write scope and an Analyst plan or higher. The query is created with parameters and is_private=False.

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

dune = DuneClient()

query = dune.create_query(
    name="Example Blockchain Query",
    query_sql="SELECT * FROM {{blockchain}}.transactions WHERE to = {{address}} AND block_number > {{blocknumber}}",
    params=[
        QueryParameter.number_type(name="blocknumber", value=0),
        QueryParameter.text_type(name="address", value="0x2ae8c972fb2e6c00dded8986e2dc672ed190da06"),
        QueryParameter.text_type(name="blockchain", value="ethereum"),
    ],
    is_private=False
)

```

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

### Python SDK get_execution_status

Source: https://docs.dune.com/api-reference/executions/endpoint/get-execution-status

Use the Dune Python SDK to retrieve execution status. Requires installing dune-client via pip. The example passes an execution_id to dune.get_execution_status().

```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 json
from dune_client.types import QueryParameter
from dune_client.client import DuneClient
from dune_client.query import QueryBase

# setup Dune Python client
dune = DuneClient()

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

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

### Python SDK: Create Query with DuneClient

Source: https://docs.dune.com/api-reference/queries/endpoint/create

Uses dune_client to create a query. The example sets name, query_sql, parameters (blocknumber as number, address as text, blockchain as text), and is_private=False. Note the parameter key 'blockchain' differs from the cURL example's 'chain'.

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

dune = DuneClient()

query = dune.create_query(
    name="Example Blockchain Query",
    query_sql="SELECT * FROM {{blockchain}}.transactions WHERE to = {{address}} AND block_number > {{blocknumber}}",
    params=[
        QueryParameter.number_type(name="blocknumber", value=0),
        QueryParameter.text_type(name="address", value="0x2ae8c972fb2e6c00dded8986e2dc672ed190da06"),
        QueryParameter.text_type(name="blockchain", value="ethereum"),
    ],
    is_private=False
)
```

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

### Configure dbt Profile (profiles.yml) for Dune

Source: https://docs.dune.com/api-reference/connectors/dbt/getting-started

Example profiles.yml for Dune dbt with dev and prod outputs. The dev schema uses DEV_SCHEMA_SUFFIX. The `transformations: true` session property is required for write access.

```yaml
dune:
  outputs:
    dev:
      type: trino
      method: jwt
      user: "{{ env_var('DUNE_TEAM_NAME') }}"
      jwt_token: "{{ env_var('DUNE_API_KEY') }}"
      host: trino.api.dune.com
      port: 443
      database: dune
      schema: "{{ env_var('DUNE_TEAM_NAME') }}__tmp_{{ env_var('DEV_SCHEMA_SUFFIX', '') }}"
      http_scheme: https
      session_properties:
        transformations: true
    
    prod:
      type: trino
      method: jwt
      user: "{{ env_var('DUNE_TEAM_NAME') }}"
      jwt_token: "{{ env_var('DUNE_API_KEY') }}"
      host: trino.api.dune.com
      port: 443
      database: dune
      schema: "{{ env_var('DUNE_TEAM_NAME') }}"
      http_scheme: https
      session_properties:
        transformations: true

  target: dev
```

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

### Understanding the execution response

Source: https://docs.dune.com/api-reference/overview/getting-started

The API returns an execution object with query status. Queries execute asynchronously; use the execution_id to check status and retrieve results. SDKs handle polling automatically.

```json
{
  "execution_id": "01K9AHMWSJZD59KAGB3WY45895",
  "state": "QUERY_STATE_EXECUTING",
  "submitted_at": "2025-11-05T17:39:48.146829Z",
  "expires_at": "2026-02-03T17:39:48.329665Z"
}
```

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

### Query Management: create, update, and execute queries

Source: https://docs.dune.com/api-reference/overview/sdks

Create a new query with QueryBase and QueryParameter, create it on Dune, update its SQL, and execute it. Prints the URL of the created query.

```python
from dune_client import DuneClient
from dune_client.query import QueryBase
from dune_client.types import QueryParameter

dune = DuneClient(api_key="YOUR_API_KEY")

# Create a new query
query = QueryBase(
    name="My DEX Analysis",
    query_sql="SELECT * FROM dex.trades WHERE blockchain = {{blockchain}}",
    params=[
        QueryParameter.text_type(name="blockchain", value="ethereum")
    ]
)

# Create the query on Dune
created_query = dune.create_query(query)
print(f"Created query: https://dune.com/queries/{created_query.query_id}")

# Update an existing query
query.query_id = created_query.query_id
query.query_sql = "SELECT * FROM dex.trades WHERE blockchain = {{blockchain}} LIMIT 1000"
dune.update_query(query)

# Execute it
results = dune.execute(query_id=created_query.query_id)
```

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

### Install TypeScript SDK with npm or yarn

Source: https://docs.dune.com/api-reference/overview/sdks

Install the @duneanalytics/client-sdk package using either npm or yarn. Choose the command that matches your package manager.

```bash
npm install @duneanalytics/client-sdk
# or
yarn add @duneanalytics/client-sdk
```

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

### varbinary_to_int256() example extracting sizeDelta as int256

Source: https://docs.dune.com/query-engine/Functions-and-operators/varbinary

Converts a big-endian varbinary of length <= 32 to an INT256, padding with zero bytes if shorter. The query extracts a 32-byte substring starting at byte 65 from the data field of optimism.logs to get a sizeDelta value, then converts it to int256. Throws an overflow exception if the varbinary exceeds 32 bytes.

```sql
select tx_hash,
       data,
       varbinary_substring(data,65,32) as sizeDelta,
       varbinary_to_int256(varbinary_substring(data,65,32)) as sizeDelta_int256
from optimism.logs
where contract_address = 0xa1ace9ce6862e865937939005b1a6c5ac938a11f
and topic0 = 0xc9d5ada2ea384fe04826ecd1b258955ac73c3e2e20d755108eafde90bc5588d4
-- sample transaction hash
and tx_hash IN (0x3e3c558e7f723e3bb7de1d8f5f920ca206e3e878984296a2b8e6af2969003a19,
                0xccfd2033adfb1fdd14fdfc047fe554ba7549e396abc6c559e9528a4259295b89)
```

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

### format() function examples

Source: https://docs.dune.com/query-engine/Functions-and-operators/conversion

Shows various format specifiers for the `format()` function, including percent signs, floating-point precision, zero-padding, comma grouping, alignment, argument indexing, and date formatting. Each example includes the expected output as a comment.

```sql
    SELECT format('%s%%', 123);
    -- '123%'

    SELECT format('%.5f', pi());
    -- '3.14159'

    SELECT format('%03d', 8);
    -- '008'

    SELECT format('%,.2f', 1234567.89);
    -- '1,234,567.89'

    SELECT format('%-7s,%7s', 'hello', 'world');
    -- 'hello  ,  world'

    SELECT format('%2$s %3$s %1$s', 'a', 'b', 'c');
    -- 'b c a'

    SELECT format('%1$tA, %1$tB %1$te, %1$tY', date '2006-07-04');
    -- 'Tuesday, July 4, 2006'
```

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

### cURL GET request to Dune API query results endpoint

Source: https://docs.dune.com/api-reference/executions/endpoint/get-query-result

Sends a GET request to https://api.dune.com/api/v1/query/{query_id}/results. Replace {query_id} with the actual query ID. No authentication header is shown in this example.

```bash
curl --request GET \
  --url https://api.dune.com/api/v1/query/{query_id}/results
  
```

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

### SELECT TIMESTAMP examples

Source: https://docs.dune.com/query-engine/datatypes

Illustrates TIMESTAMP literal construction, precision, and casting behavior (rounding down, appending zeros).

```sql
    SELECT TIMESTAMP '2020-06-10 15:55:23';
    -- 2020-06-10 15:55:23

    SELECT TIMESTAMP '2020-06-10 15:55:23.383345';
    -- 2020-06-10 15:55:23.383345

    SELECT typeof(TIMESTAMP '2020-06-10 15:55:23.383345');
    -- timestamp(6)

    SELECT cast(TIMESTAMP '2020-06-10 15:55:23.383345' as TIMESTAMP(1));
     -- 2020-06-10 15:55:23.4

    SELECT cast(TIMESTAMP '2020-06-10 15:55:23.383345' as TIMESTAMP(12));
    -- 2020-06-10 15:55:23.383345000000
```

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

### Go: Create Query with net/http

Source: https://docs.dune.com/api-reference/queries/endpoint/create

Uses net/http to POST to https://api.dune.com/api/v1/query. The payload is a JSON string with name, description, parameters (address, blocknumber, chain), query_sql, and is_private. The chain parameter is an enum with options ethereum, polygon, optimism, arbitrum, avalanche_c, gnosis, bnb. Prints the response and body.

```go
package main

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

func main() {

	url := "https://api.dune.com/api/v1/query"

	payload := strings.NewReader("{\n  \"name\": \"erc20 balances (user address) API\",\n  \"description\": \"Example Blockchain Query\",\n  \"parameters\": [\n    {\n      \"key\": \"address\",\n      \"value\": \"0x2ae8c972fb2e6c00dded8986e2dc672ed190da06\",\n      \"type\": \"text\"\n    },\n    {\n      \"key\": \"blocknumber\",\n      \"value\": \"0\",\n      \"type\": \"number\"\n    },\n    {\n      \"key\": \"chain\",\n      \"value\": \"ethereum\",\n      \"type\": \"enum\",\n      \"enumOptions\": [\n        \"ethereum\",\n        \"polygon\",\n        \"optimism\",\n        \"arbitrum\",\n        \"avalanche_c\",\n        \"gnosis\",\n        \"bnb\"\n      ]\n    }\n  ],\n  \"query_sql\": \"SELECT * FROM {{blockchain}}.transactions WHERE to = {{address}} AND block_number > {{blocknumber}}\",\n  \"is_private\": true\n}")

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

	req.Header.Add("X-DUNE-API-KEY", "<x-dune-api-key>")
	req.Header.Add("Content-Type", "application/json")

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

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

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

}
```

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

### Python SDK: Get Execution Result CSV

Source: https://docs.dune.com/api-reference/executions/endpoint/get-execution-result-csv

Use the Dune Python SDK to download execution results as CSV. Install with `pip install dune-client`. Pass the execution_id to `get_execution_results_csv`.

```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 json
from dune_client.types import QueryParameter
from dune_client.client import DuneClient
from dune_client.query import QueryBase

# setup Dune Python client
dune = DuneClient()

result = dune.get_execution_results_csv(job_id = '01HM7F50BXZVPHJNWJQM6GMS1M') # pass in the execution_id
```

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

### Create Query with Java Unirest

Source: https://docs.dune.com/api-reference/queries/endpoint/create

Java example using Unirest to POST to https://api.dune.com/api/v1/query. Requires X-DUNE-API-KEY with Read/Write scope and an Analyst plan or higher. The body is a JSON string with parameters and query_sql.

```java
HttpResponse<String> response = Unirest.post("https://api.dune.com/api/v1/query")
  .header("X-DUNE-API-KEY", "<x-dune-api-key>")
  .header("Content-Type", "application/json")
  .body("{\n  \"name\": \"erc20 balances (user address) API\",\n  \"description\": \"Example Blockchain Query\",\n  \"parameters\": [\n    {\n      \"key\": \"address\",\n      \"value\": \"0x2ae8c972fb2e6c00dded8986e2dc672ed190da06\",\n      \"type\": \"text\"\n    },\n    {\n      \"key\": \"blocknumber\",\n      \"value\": \"0\",\n      \"type\": \"number\"\n    },\n    {\n      \"key\": \"chain\",\n      \"value\": \"ethereum\",\n      \"type\": \"enum\",\n      \"enumOptions\": [\n        \"ethereum\",\n        \"polygon\",\n        \"optimism\",\n        \"arbitrum\",\n        \"avalanche_c\",\n        \"gnosis\",\n        \"bnb\"\n      ]\n    }\n  ],\n  \"query_sql\": \"SELECT * FROM {{blockchain}}.transactions WHERE to = {{address}} AND block_number > {{blocknumber}}\",\n  \"is_private\": true\n}")
  .asString();

```

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

### varbinary_starts_with(varbinary, varbinary) - Example

Source: https://docs.dune.com/query-engine/Functions-and-operators/varbinary

Determines whether a varbinary starts with a prefix.

```APIDOC
## varbinary_starts_with(varbinary, varbinary)

### Description
Determines whether a varbinary starts with a prefix.

### Signature
`varbinary_starts_with(varbinary, varbinary)` → boolean

### Example
```sql
-- returns true if starts with 0x3d13f874
SELECT varbinary_starts_with(0x3d13f874abcd,0x3d13f874) 
```

```

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

### Successful response schema for get dataset

Source: https://docs.dune.com/api-reference/datasets/endpoint/get

Example 200 response body for the get dataset endpoint, showing dataset metadata, columns, and owner information.

```json
{
  "columns": [
    {
      "metadata": {
        "description": "<string>",
        "filtering_column": true
      },
      "name": "<string>",
      "nullable": true,
      "type": "<string>"
    }
  ],
  "created_at": "<string>",
  "full_name": "<string>",
  "is_private": true,
  "metadata": "<unknown>",
  "owner": {
    "handle": "<string>",
    "type": "<string>"
  },
  "type": "<string>",
  "updated_at": "<string>"
}
```

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

### SHOW COLUMNS example

Source: https://docs.dune.com/api-reference/connectors/sql-operations

Lists all columns in a table.

```sql
SHOW COLUMNS FROM your_team.users;
```

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

### Java Unirest GET query pipeline

Source: https://docs.dune.com/api-reference/queries/endpoint/get-query-pipeline

Uses the Unirest HTTP library to send a GET request with the API key header and returns the response as a string.

```java
HttpResponse<String> response = Unirest.get("https://api.dune.com/api/v1/query/{query_id}/pipeline")
  .header("X-Dune-Api-Key", "<x-dune-api-key>")
  .asString();
```

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

### PHP cURL GET query pipeline

Source: https://docs.dune.com/api-reference/queries/endpoint/get-query-pipeline

Uses PHP cURL to send a GET request to the pipeline endpoint. Prints the response or a cURL error if one occurs.

```php
<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.dune.com/api/v1/query/{query_id}/pipeline",
  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;
}
```

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

### Execute query with Python SDK

Source: https://docs.dune.com/api-reference/overview/introduction

Initialize DuneClient with your API key and call execute() to run a query and get results. The execute() function handles polling and pagination automatically.

```python
from dune_client import DuneClient

dune = DuneClient(api_key="your-key")
results = dune.execute(query_id=3493826)
```

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

### SHOW CREATE TABLE example

Source: https://docs.dune.com/api-reference/connectors/sql-operations

Views the DDL for a table, returning the full CREATE TABLE statement including table properties like privacy settings. Requires the `transformations=true` session property.

```sql
SHOW CREATE TABLE your_team.users;
```
Tokens:
Raw