> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://apidocs.polytomic.com/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://apidocs.polytomic.com/_mcp/server.

## Code

Set your Polytomic API key as an environment variable:

```bash
export POLYTOMIC_API_KEY=YOUR-API-TOKEN
```

This example covers three steps:

1. Create a Salesforce Connection.
2. Run a SOQL query on that Connection.
3. Read the query results from Polytomic.

## 1. Create a Salesforce connection

The following request creates a Salesforce Connection. See the [Salesforce connection configuration](/guides/configuring-your-connections/connections/salesforce) for the required fields.

#### cURL

```bash
curl --request POST  \
     --url https://app.polytomic.com/api/connections \
     --header "accept: application/json"  \
     --header "content-type: application/json"  \
     --header "X-Polytomic-Version: 2024-02-08"   \
     --header "Authorization: Bearer ${POLYTOMIC_API_KEY}"  \
     -d '{"name": "Salesforce Connection","type": "salesforce", "configuration": {"domain": "https://example.my.salesforce.com"}}'
```

#### Python

```python
import os
from polytomic.client import Polytomic

client = Polytomic(
    token=os.getenv("POLYTOMIC_API_KEY"),
)

resp = client.connections.create(
    name="Salesforce Connection",
    configuration={"domain": "https://example.my.salesforce.com"},
    type="salesforce"
)

print(resp.data)
```

#### Typescript

```typescript

import { PolytomicClient } from 'polytomic';

const polytomic = new PolytomicClient({
  token: "POLYTOMIC_API_KEY",
});

polytomic.connections.create({
  name: "Salesforce Connection",
  type: "salesforce",
  configuration: {
     domain: "https://example.my.salesforce.com"
  },

}).then((res) => {
  console.log(res)
})

```

#### Go

```golang

import (
	"context"
	"fmt"

	polytomic "github.com/polytomic/polytomic-go"
	polytomicgoclient "github.com/polytomic/polytomic-go/client"
	"github.com/polytomic/polytomic-go/option"
)

client := polytomicgoclient.NewClient(
    option.WithToken(os.Getenv("POLYTOMIC_API_TOKEN")),
)

resp, err := client.Connections.Create(
    context.TODO(),
    &polytomic.CreateConnectionRequestSchema{
        Name:          "Salesforce Connection",
        Type:          "salesforce",
        Configuration: map[string]interface{}{
          "domain": "https://example.my.salesforce.com",
        },
    },
)
if err != nil {
    panic(err)
}
fmt.Println(resp)
```

Salesforce Connections authenticate with OAuth. Open the URL returned in the `auth_url` field of the response to complete the flow.

> **OAuth redirection**
>
> By default, the API expects `auth_url` to open in a new browser window.
> Set the optional `redirect_url` parameter in the request body to change
> the redirect target.

## 2. Start a SOQL query

The following request starts a SOQL query on the Salesforce Connection. The results are available through the Polytomic API once the query completes.

#### cURL

```bash
     curl --request POST \
     --url https://app.polytomic.com/api/connections/SALESFORCE-CONNECTION-ID/query \
     --header "accept: application/json" \
     --header "content-type: application/json" \
     --header "X-Polytomic-Version: 2024-02-08"  \
     --header "Authorization: Bearer ${POLYTOMIC_API_KEY}" \
     -d '{
     "query": "SELECT Id, Name FROM Account"
    }'
```

#### Python

```python
import os
from polytomic.client import Polytomic

client = Polytomic(
    token=os.getenv("POLYTOMIC_API_KEY"),
)

query = """
SELECT Account__c, COUNT(ID) num_active_ FROM Business_Unit__c
WHERE Status__c = 'Active' AND Subscription_Type__c == 'Self Service'
GROUP BY Account__c
"""

resp = client.query_runner.run_query(
  connection_id="SALESFORCE-CONNECTION-ID",
  query=query,
)

print(resp.data)
```

#### Typescript

```typescript

import { PolytomicClient } from 'polytomic';

const polytomic = new PolytomicClient({
  token: "POLYTOMIC_API_KEY",
});


polytomic.queryRunner.runQuery({
  connectionId: "SALESFORCE-CONNECTION-ID",
  query: query,
}).then((res) => {
  console.log(res.data);
});
```

#### Go

```golang

import (
	"context"
	"fmt"

	polytomic "github.com/polytomic/polytomic-go"
	polytomicgoclient "github.com/polytomic/polytomic-go/client"
)

func main() {
    client := polytomicgoclient.NewClient(polytomic.WithToken(os.Getenv("POLYTOMIC_API_TOKEN")))

    query := `
SELECT Account__c, COUNT(ID) num_active_ FROM Business_Unit__c
WHERE Status__c = 'Active' AND Subscription_Type__c = 'Self Service'
GROUP BY Account__c
`

    resp, err := client.QueryRunner.RunQuery(context.TODO(), &polytomic.RunQueryRequest{
        ConnectionId: "SALESFORCE-CONNECTION-ID",
        Query:        query,
    })

    if err != nil {
        fmt.Println("Error running query:", err)
        return
    }

    fmt.Println("Query Results:", resp.Data)
}
```

## 3. Read the query results

Poll the query endpoint until the status is `done` or `failed`, then read the results:

#### cURL

```bash
curl --request GET \
     --url https://app.polytomic.com/api/queries/QUERY_ID \
     --header "accept: application/json" \
     --header "Authorization: Bearer ${POLYTOMIC_API_KEY}"
```

#### Python

```python

import os
from polytomic.client import Polytomic
from polytomic import BulkSchedule

client = Polytomic(
    token=os.getenv("POLYTOMIC_API_KEY"),
)

resp = client.query_runner.get_query(id="QUERY_ID")
while resp.data.status != "done" and resp.data.status != "failed":
    sleep(5)
    print(
        ".",
    )
    resp = client.query_runner.get_query(id=query_id)

print()
print(f"Status: {resp.data.status}")
if status == "failed":
    print(f"Error: {resp.data.error}")
else:
    print(f"Query ID: {resp.data.id}")
    print("Query Result:")
    for result in resp.data.results:
        print(result)
```

#### Typescript

```typescript

import { PolytomicClient } from 'polytomic';

const polytomic = new PolytomicClient({
  token: "POLYTOMIC_API_KEY",
});

```

#### Go

```golang
package main

import (
    "context"
    "fmt"
    "os"
    "time"

    polytomic "github.com/polytomic/polytomic-go"
    polytomicgoclient "github.com/polytomic/polytomic-go/client"
)

func main() {
    client := polytomicgoclient.NewClient(polytomic.WithToken(os.Getenv("POLYTOMIC_API_TOKEN")))

    queryID := "QUERY_ID"

    for {
        resp, err := client.QueryRunner.GetQuery(context.Background(), queryID)
        if err != nil {
            fmt.Println("Error fetching query results:", err)
            return
        }

        if resp.Data.Status == "done" {
            fmt.Println("Query completed successfully.")
            for _, result := range resp.Data.Results {
                fmt.Println(result)
            }
            break
        } else if resp.Data.Status == "failed" {
            fmt.Println("Query failed with error:", resp.Data.Error)
            break
        } else {
            fmt.Println("Query is still running...")
            time.Sleep(5 * time.Second)
        }
    }
}
```