---
title: "Local instances"
description: "Connect to locally hosted Weaviate instances with code examples in Python, TypeScript, Go, Java, and C#."
url: https://docs.weaviate.io/weaviate/connections/connect-local
---

# Local instances

Follow these steps to connect to a locally hosted Weaviate instance.

## Local connection URL

Docker instances default to `http://localhost:8080`. The gRPC port, `50051`, is also on `localhost`.

If your instance runs on Kubernetes, see the `host` and `port` values in your Helm chart's `values.yaml` file.

## No authentication enabled

To connect to a local instance without authentication, follow these examples.

**Python**

```py
import weaviate

client = weaviate.connect_to_local()

print(client.is_ready())
```

**JavaScript/TypeScript**

```ts
import weaviate, { WeaviateClient } from '@weaviate/node';


const client = await weaviate.connectToLocal()

console.log(client)
```

**Go (v5)**

```go
package main

import (
"context"
"fmt"

"github.com/weaviate/weaviate-go-client/v5/weaviate"
)

// Create the client
func CreateClient() {
cfg := weaviate.Config{
Host:       "localhost:8080",
Scheme:     "http",
        Headers:    nil,
}

client, err := weaviate.NewClient(cfg)
if err != nil {
fmt.Println(err)
}

// Check the connection
live, err := client.Misc().LiveChecker().Do(context.Background())
if err != nil {
panic(err)
}
fmt.Printf("%v", live)

}

func main() {
CreateClient()
}
```

**Go (v6)**

```go
client, err := weaviate.NewLocal(ctx)
if err != nil {
  // handle error
  panic(err)
}
defer client.Close()

ready, err := client.IsReady(ctx)
if err != nil {
  // handle error
  panic(err)
}
fmt.Println(ready)
```

**Java**

```java
WeaviateClient client = WeaviateClient.connectToLocal();

System.out.println(client.isReady()); // Should print: `True`

client.close(); // Free up resources
```

**C#**

```csharp
WeaviateClient client = await Connect.Local();

var isReady = await client.IsReady();
Console.WriteLine(isReady);
```

**Shell**

```shell
curl http://localhost:8080/v1/meta | jq
```

## Change the URL or port

To change the default URL or port number, follow these examples.

**Python**

```py
import weaviate

client = weaviate.connect_to_local(
    host="127.0.0.1",  # Use a string to specify the host
    port=8080,
    grpc_port=50051,
)

print(client.is_ready())
```

**JavaScript/TypeScript**

```ts
import weaviate, { WeaviateClient } from '@weaviate/node';


const client = await weaviate.connectToLocal(
 {
    host: "127.0.0.1",   // URL only, no http prefix
    port: 8080,
    grpcPort: 50051,     // Default is 50051, WCD uses 443
 })

async function main() {
  console.log(await client.isReady())
  await client.close()
}

main()
```

**Go (v5)**

```go
package main

import (
"context"
"fmt"

"github.com/weaviate/weaviate-go-client/v5/weaviate"
)

// Create the client
func CreateClient() {
cfg := weaviate.Config{
Host:       "localhost:8080",
Scheme:     "http",
        Headers:    nil,
        // The Go client doesn't use the gRPC port
}

client, err := weaviate.NewClient(cfg)
if err != nil {
fmt.Println(err)
}

// Check the connection
live, err := client.Misc().LiveChecker().Do(context.Background())
if err != nil {
panic(err)
}
fmt.Printf("%v", live)

}

func main() {
CreateClient()
}
```

**Go (v6)**

```go
client, err := weaviate.NewClient(ctx,
  weaviate.WithScheme("http"),
  weaviate.WithHTTPHost("127.0.0.1"),
  weaviate.WithHTTPPort("8080"),
  weaviate.WithGRPCHost("127.0.0.1"),
  weaviate.WithGRPCPort("50051"),
)
if err != nil {
  // handle error
  panic(err)
}
defer client.Close()

ready, err := client.IsReady(ctx)
if err != nil {
  // handle error
  panic(err)
}
fmt.Println(ready)
```

**Java**

```java
WeaviateClient client = WeaviateClient
    .connectToLocal(config -> config.host("127.0.0.1").port(8080));

System.out.println(client.isReady()); // Should print: `True`

client.close(); // Free up resources
```

**C#**

```csharp
WeaviateClient client = await WeaviateClientBuilder
    .Custom(
        restEndpoint: "127.0.0.1",
        restPort: "8080",
        grpcEndpoint: "127.0.0.1",
        grpcPort: "50051",
        useSsl: false
    )
    .BuildAsync();

var isReady = await client.IsReady();
Console.WriteLine(isReady);
```

**Shell**

```shell
curl http://localhost:8080/v1/meta | jq
# The cURL connection doesn't use the gRPC port
```

## Authentication enabled

To authenticate with a Weaviate API key, follow these examples.

**Python**

```py
import os
import weaviate
from weaviate.classes.init import Auth

# Best practice: store your credentials in environment variables
weaviate_api_key = os.environ["WEAVIATE_API_KEY"]

client = weaviate.connect_to_local(
    auth_credentials=Auth.api_key(weaviate_api_key)
)

print(client.is_ready())

assert client.is_ready()
```

**JavaScript/TypeScript**

```ts
import weaviate, { WeaviateClient } from '@weaviate/node';

// Set this environment variable
// WEAVIATE_LOCAL_API_KEY   your Weaviate instance API key

const weaviateKey = process.env.WEAVIATE_LOCAL_API_KEY as string

const client = await weaviate.connectToLocal(
   { 
    port:8099,
    grpcPort:50052, 
    authCredentials: new weaviate.ApiKey(weaviateKey)
  }
)

console.log(client)
```

**Go (v5)**

```go
// Set this environment variable
// WEAVIATE_API_KEY  your Weaviate instance API key

package main

import (
"context"
"fmt"
"os"

"github.com/weaviate/weaviate-go-client/v5/weaviate"
    "github.com/weaviate/weaviate-go-client/v5/weaviate/auth"
)

// Create the client
func CreateClient() {
cfg := weaviate.Config{
Host:       "localhost:8080",
Scheme:     "http",
        AuthConfig: auth.ApiKey{Value: os.Getenv("WEAVIATE_API_KEY")},
        Headers:    nil,
}

client, err := weaviate.NewClient(cfg)
if err != nil {
fmt.Println(err)
}

// Check the connection
live, err := client.Misc().LiveChecker().Do(context.Background())
if err != nil {
panic(err)
}
fmt.Printf("%v", live)

}

func main() {
CreateClient()
}
```

**Go (v6)**

```go
// Best practice: store your credentials in environment variables
client, err := weaviate.NewLocal(ctx,
  weaviate.WithAPIKey(os.Getenv("WEAVIATE_API_KEY")),
)
if err != nil {
  // handle error
  panic(err)
}
defer client.Close()

ready, err := client.IsReady(ctx)
if err != nil {
  // handle error
  panic(err)
}
fmt.Println(ready)
```

**Java**

```java
// Best practice: store your credentials in environment variables
final String weaviateApiKey = System.getenv("WEAVIATE_LOCAL_API_KEY");

WeaviateClient client =
    WeaviateClient.connectToLocal(config -> config.host("127.0.0.1")
        .port(8099)
        .grpcPort(50052)
        .authentication(Authentication.apiKey(weaviateApiKey)));

System.out.println(client.isReady()); // Should print: `True`

client.close(); // Free up resources
```

**C#**

```csharp
// Best practice: store your credentials in environment variables
string weaviateApiKey = Environment.GetEnvironmentVariable("WEAVIATE_LOCAL_API_KEY");

WeaviateClient client = await Connect.Local(
    hostname: "127.0.0.1",
    restPort: 8099,
    grpcPort: 50052,
    credentials: Auth.ApiKey(weaviateApiKey)
);

var isReady = await client.IsReady();
Console.WriteLine(isReady);
```

**Shell**

```shell
# Set this environment variable
# WEAVIATE_API_KEY  your Weaviate instance API key

curl http://localhost:8080/v1/meta -H "Authorization: Bearer ${WEAVIATE_API_KEY}" | jq
```

### OIDC authentication

For additional client examples, see [OIDC authentication](https://docs.weaviate.io/weaviate/connections/connect-custom#oidc-authentication).

## Third party API keys

Integrations that use external APIs often need API keys. To add third party API keys, follow these examples:

**Python**

```py
import os
import weaviate

# Best practice: store your credentials in environment variables
cohere_api_key = os.environ["COHERE_API_KEY"]

client = weaviate.connect_to_local(
    headers={
        "X-Cohere-Api-Key": cohere_api_key
    }
)

print(client.is_ready())
```

**JavaScript/TypeScript**

```ts
import weaviate, { WeaviateClient } from '@weaviate/node';

// Set this environment variable
// COHERE_API_KEY    your Cohere API key

const cohereKey = process.env.COHERE_API_KEY as string

const client = await weaviate.connectToLocal(
  {
    headers: {
     'X-Cohere-Api-Key':  cohereKey,
    }
  }
)

console.log(client)
```

**Go (v5)**

```go
// Set this environment variable
// COHERE_API_KEY    your Cohere API key

package main

import (
"context"
"fmt"
"os"

"github.com/weaviate/weaviate-go-client/v5/weaviate"
)

// Create the client
func CreateClient() {
cfg := weaviate.Config{
Host:       "localhost:8080",
Scheme:     "http",
        Headers:     map[string]string{
            "X-Cohere-Api-Key": os.Getenv("WEAVIATE_COHERE_KEY"),
        },
}

client, err := weaviate.NewClient(cfg)
if err != nil {
fmt.Println(err)
}

// Check the connection
live, err := client.Misc().LiveChecker().Do(context.Background())
if err != nil {
panic(err)
}
fmt.Printf("%v", live)

}

func main() {
CreateClient()
}
```

**Go (v6)**

```go
client, err := weaviate.NewLocal(ctx,
  weaviate.WithHeader(http.Header{
    "X-Cohere-Api-Key": []string{os.Getenv("COHERE_API_KEY")},
  }),
)
if err != nil {
  // handle error
  panic(err)
}
defer client.Close()

ready, err := client.IsReady(ctx)
if err != nil {
  // handle error
  panic(err)
}
fmt.Println(ready)
```

**Java**

```java
// Best practice: store your credentials in environment variables
final String cohereApiKey = System.getenv("COHERE_API_KEY");

WeaviateClient client = WeaviateClient.connectToLocal(
    config -> config.setHeaders(Map.of("X-Cohere-Api-Key", cohereApiKey)));

System.out.println(client.isReady()); // Should print: `True`

client.close(); // Free up resources
```

**C#**

```csharp
// Best practice: store your credentials in environment variables
string cohereApiKey = Environment.GetEnvironmentVariable("COHERE_API_KEY");

WeaviateClient client = await WeaviateClientBuilder
    .Local(hostname: "localhost", restPort: 8080, grpcPort: 50051, useSsl: false)
    .WithHeaders(new Dictionary<string, string> { { "X-Cohere-Api-Key", cohereApiKey } })
    .BuildAsync();

var isReady = await client.IsReady();
Console.WriteLine(isReady);
```

**Shell**

```shell
# Set this environment variable
# COHERE_API_KEY    your Cohere API key

curl http://localhost:8080/v1/meta \
-H 'Content-Type: application/json' \
-H "X-Cohere-Api-Key: ${COHERE_API_KEY}" | jq
```

## Environment variables

> [!WARNING]
>
> Do not hard-code API keys or other credentials in your client code. Use environment variables or a similar secure coding technique instead.

Environment variables keep sensitive details out of your source code. Your application imports the information to runtime.

**Set an environment variable.**

In these examples, the environment variable names are in UPPER\_CASE.

**Bash**

```bash
export WEAVIATE_URL="http://localhost:8080"
export WEAVIATE_API_KEY="sAmPleKEY8FwELJILn0YDRG9gjy4hReqfInz"
```

**Windows PowerShell**

```shell
$Env:WEAVIATE_URL="http://localhost:8080"
$Env:WEAVIATE_API_KEY="sAmPleKEY8FwELJILn0YDRG9gjy4hReqfInz"
```

**Windows Command Prompt**

```shell
set WEAVIATE_URL=http://localhost:8080
set WEAVIATE_API_KEY=sAmPleKEY8FwELJILn0YDRG9gjy4hReqfInz
```

**Import an environment variable.**

**Python**

```python
weaviate_url = os.getenv("WEAVIATE_URL")
weaviate_key = os.getenv("WEAVIATE_API_KEY")
```

**JavaScript/TypeScript**

```js
const weaviateUrl = process.env.WEAVIATE_URL;
const weaviateKey = process.env.WEAVIATE_API_KEY;
```

**Go (v5)**

```go
weaviateUrl := os.Getenv("WEAVIATE_URL")
weaviateKey := os.Getenv("WEAVIATE_API_KEY")
```

## gRPC timeouts

The Python client v4 and TypeScript client v3 use [gRPC](https://docs.weaviate.io/weaviate/api/grpc). The gRPC protocol is sensitive to network delay. If you encounter connection timeouts, adjust the timeout values for initialization, queries, and insertions.

**Python**

```py
import weaviate
from weaviate.classes.init import AdditionalConfig, Timeout

client = weaviate.connect_to_local(
    port=8080,
    grpc_port=50051,
    additional_config=AdditionalConfig(
        timeout=Timeout(init=30, query=60, insert=120)  # Values in seconds
    )
)

print(client.is_ready())
```

**JavaScript/TypeScript**

```ts
import weaviate, { WeaviateClient } from '@weaviate/node';


const client = await weaviate.connectToLocal(
   {  timeout: { init: 30, query: 60, insert: 120 }, } // Values in seconds
)

console.log(client)
```

**Java**

```java
WeaviateClient client =
    WeaviateClient.connectToLocal(config -> config.timeout(30, 60, 120)); // Values in seconds

System.out.println(client.isReady()); // Should print: `True`

client.close(); // Free up resources
```

**C#**

```csharp
WeaviateClient client = await Connect.Local(
    initTimeout: TimeSpan.FromSeconds(30),
    queryTimeout: TimeSpan.FromSeconds(60),
    insertTimeout: TimeSpan.FromSeconds(120)
);

var isReady = await client.IsReady();
Console.WriteLine(isReady);
```
