The [Python client](../client-libraries/python.md) and the [TypeScript client](../client-libraries/typescript.md) provide helper methods for common connection types. They also provide custom methods for when you need additional connection configuration. If you are using one of the other clients, the standard connection methods are configurable for all connections. :::code-group{sync="languages"} ```python title="Python" import weaviate, os from weaviate.classes.init import Auth from weaviate.config import AdditionalConfig, Timeout # Best practice: store your credentials in environment variables http_host = os.environ["WEAVIATE_HTTP_HOST"] grpc_host = os.environ["WEAVIATE_GRPC_HOST"] weaviate_api_key = os.environ["WEAVIATE_API_KEY"] ``` ```typescript title="JavaScript/TypeScript" // Set these environment variables // WEAVIATE_HTTP_HOST your Weaviate instance URL // WEAVIATE_GRPC_HOST your Weaviate instance GPC URL // WEAVIATE_API_KEY your Weaviate instance API key const client = await weaviate.connectToCustom( { httpHost: process.env.WEAVIATE_HTTP_HOST, // URL only, no http prefix httpPort: 443, grpcHost: process.env.WEAVIATE_GRPC_HOST, grpcPort: 443, // Default is 50051, WCD uses 443 grpcSecure: true, httpSecure: true, authCredentials: new weaviate.ApiKey(process.env.WEAVIATE_API_KEY), ``` ```java title="Java" // Best practice: store your credentials in environment variables String httpHost = System.getenv("WEAVIATE_HTTP_HOST"); String grpcHost = System.getenv("WEAVIATE_GRPC_HOST"); String weaviateApiKey = System.getenv("WEAVIATE_API_KEY"); String cohereApiKey = System.getenv("COHERE_API_KEY"); WeaviateClient client = WeaviateClient.connectToCustom(config -> config.scheme("https") // Corresponds to http_secure=True and grpc_secure=True .httpHost(httpHost) .httpPort(443) .grpcHost(grpcHost) .grpcPort(443) .authentication(Authentication.apiKey(weaviateApiKey)) .setHeaders(Map.of("X-Cohere-Api-Key", cohereApiKey))); System.out.println(client.isReady()); // Should print: `True` client.close(); // Free up resources ``` ```csharp title="C#" // Best practice: store your credentials in environment variables string httpHost = Environment.GetEnvironmentVariable("WEAVIATE_HTTP_HOST"); string grpcHost = Environment.GetEnvironmentVariable("WEAVIATE_GRPC_HOST"); string weaviateApiKey = Environment.GetEnvironmentVariable("WEAVIATE_API_KEY"); string cohereApiKey = Environment.GetEnvironmentVariable("COHERE_API_KEY"); WeaviateClient client = await WeaviateClientBuilder .Custom( restEndpoint: httpHost, restPort: "443", grpcEndpoint: grpcHost, grpcPort: "443", useSsl: true ) .WithCredentials(Auth.ApiKey(weaviateApiKey)) .WithHeaders(new Dictionary { { "X-Cohere-Api-Key", cohereApiKey } }) .BuildAsync(); var isReady = await client.IsReady(); Console.WriteLine(isReady); ``` ::: ## Environment variables :::callout{intent="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. ::::accordion{title="Set an environment variable."} In these examples, the environment variable names are in UPPER\_CASE. :::code-group{sync="languages"} ```bash title="Bash/Zsh" export WEAVIATE_URL="http://localhost:8080" export WEAVIATE_API_KEY="sAmPleKEY8FwELJILn0YDRG9gjy4hReqfInz" ``` ```shell title="Windows PowerShell" $Env:WEAVIATE_URL="http://localhost:8080" $Env:WEAVIATE_API_KEY="sAmPleKEY8FwELJILn0YDRG9gjy4hReqfInz" ``` ```shell title="Windows Command Prompt" set WEAVIATE_URL=http://localhost:8080 set WEAVIATE_API_KEY=sAmPleKEY8FwELJILn0YDRG9gjy4hReqfInz ``` ::: :::: ::::accordion{title="Import an environment variable."} :::code-group{sync="languages"} ```python title="Python" weaviate_url = os.getenv("WEAVIATE_URL") weaviate_key = os.getenv("WEAVIATE_API_KEY") ``` ```js title="JavaScript/TypeScript" const weaviateUrl = process.env.WEAVIATE_URL; const weaviateKey = process.env.WEAVIATE_API_KEY; ``` ```go title="Go" weaviateUrl := os.Getenv("WEAVIATE_URL") weaviateKey := os.Getenv("WEAVIATE_API_KEY") ``` ::: :::: ## gRPC Timeouts The Python client v4 and TypeScript client v3 use [gRPC](../apis/grpc.md). The gRPC protocol is sensitive to network delay. If you encounter connection timeouts, adjust the timeout values for initialization, queries, and insertions. :::code-group{sync="languages"} ```python title="Python" import weaviate, os from weaviate.classes.init import Auth from weaviate.config import AdditionalConfig, Timeout # Best practice: store your credentials in environment variables http_host = os.environ["WEAVIATE_HTTP_HOST"] grpc_host = os.environ["WEAVIATE_GRPC_HOST"] weaviate_api_key = os.environ["WEAVIATE_API_KEY"] ``` ```typescript title="JavaScript/TypeScript" // Set these environment variables // WEAVIATE_HTTP_HOST your Weaviate instance URL // WEAVIATE_GRPC_HOST your Weaviate instance GPC URL // WEAVIATE_API_KEY your Weaviate instance API key const client: WeaviateClient = await weaviate.connectToCustom( { httpHost: process.env.WEAVIATE_HTTP_HOST, // URL only, no http prefix httpPort: 443, grpcHost: process.env.WEAVIATE_GRPC_HOST, grpcPort: 443, // Default is 50051, WCD uses 443 grpcSecure: true, httpSecure: true, authCredentials: new weaviate.ApiKey(process.env.WEAVIATE_API_KEY), timeout: { init: 30, query: 60, insert: 120 } // Values in seconds } ) console.log(client) ``` ```java title="Java" // Best practice: store your credentials in environment variables String httpHost = System.getenv("WEAVIATE_HTTP_HOST"); String grpcHost = System.getenv("WEAVIATE_GRPC_HOST"); String weaviateApiKey = System.getenv("WEAVIATE_API_KEY"); String cohereApiKey = System.getenv("COHERE_API_KEY"); WeaviateClient client = WeaviateClient.connectToCustom(config -> config.scheme("https") // Corresponds to http_secure=True and grpc_secure=True .httpHost(httpHost) .httpPort(443) .grpcHost(grpcHost) .grpcPort(443) .authentication(Authentication.apiKey(weaviateApiKey)) .setHeaders(Map.of("X-Cohere-Api-Key", cohereApiKey)) .timeout(30, 60, 120)); // Values in seconds System.out.println(client.isReady()); // Should print: `True` client.close(); // Free up resources ``` ```csharp title="C#" // Best practice: store your credentials in environment variables string httpHost = Environment.GetEnvironmentVariable("WEAVIATE_HTTP_HOST"); string grpcHost = Environment.GetEnvironmentVariable("WEAVIATE_GRPC_HOST"); string weaviateApiKey = Environment.GetEnvironmentVariable("WEAVIATE_API_KEY"); string cohereApiKey = Environment.GetEnvironmentVariable("COHERE_API_KEY"); WeaviateClient client = await WeaviateClientBuilder .Custom( restEndpoint: httpHost, restPort: "443", grpcEndpoint: grpcHost, grpcPort: "443", useSsl: true ) .WithCredentials(Auth.ApiKey(weaviateApiKey)) .WithHeaders(new Dictionary { { "X-Cohere-Api-Key", cohereApiKey } }) .WithInitTimeout(TimeSpan.FromSeconds(30)) .WithQueryTimeout(TimeSpan.FromSeconds(60)) .WithInsertTimeout(TimeSpan.FromSeconds(120)) .BuildAsync(); var isReady = await client.IsReady(); Console.WriteLine(isReady); ``` ::: ## Third party API keys Integrations that use external APIs often need API keys. To add third party API keys, follow these examples: :::code-group{sync="languages"} ```python title="Python" import weaviate, os from weaviate.classes.init import Auth from weaviate.config import AdditionalConfig, Timeout # Best practice: store your credentials in environment variables http_host = os.environ["WEAVIATE_HTTP_HOST"] grpc_host = os.environ["WEAVIATE_GRPC_HOST"] weaviate_api_key = os.environ["WEAVIATE_API_KEY"] cohere_api_key = os.environ["COHERE_API_KEY"] client = weaviate.connect_to_custom( http_host=http_host, # Hostname for the HTTP API connection http_port=443, # Default is 80, WCD uses 443 http_secure=True, # Whether to use https (secure) for the HTTP API connection grpc_host=grpc_host, # Hostname for the gRPC API connection grpc_port=443, # Default is 50051, WCD uses 443 grpc_secure=True, # Whether to use a secure channel for the gRPC API connection auth_credentials=Auth.api_key(weaviate_api_key), # API key for authentication headers={"X-Cohere-Api-Key": cohere_api_key}, # Third party API key (e.g. Cohere) ``` ```typescript title="JavaScript/TypeScript" // Set these environment variables // WEAVIATE_HTTP_HOST your Weaviate instance URL // WEAVIATE_GRPC_HOST your Weaviate instance GPC URL // WEAVIATE_API_KEY your Weaviate instance API key const client = await weaviate.connectToCustom( { httpHost: process.env.WEAVIATE_HTTP_HOST, // URL only, no http prefix httpPort: 443, grpcHost: process.env.WEAVIATE_GRPC_HOST, grpcPort: 443, // Default is 50051, WCD uses 443 grpcSecure: true, httpSecure: true, authCredentials: new weaviate.ApiKey(process.env.WEAVIATE_API_KEY), headers: { 'X-Cohere-Api-Key': process.env.COHERE_API_KEY || '' } }) console.log(client) ``` ```java title="Java" // Best practice: store your credentials in environment variables String httpHost = System.getenv("WEAVIATE_HTTP_HOST"); String grpcHost = System.getenv("WEAVIATE_GRPC_HOST"); String weaviateApiKey = System.getenv("WEAVIATE_API_KEY"); String cohereApiKey = System.getenv("COHERE_API_KEY"); WeaviateClient client = WeaviateClient.connectToCustom(config -> config.scheme("https") // Corresponds to http_secure=True and grpc_secure=True .httpHost(httpHost) .httpPort(443) .grpcHost(grpcHost) .grpcPort(443) .authentication(Authentication.apiKey(weaviateApiKey)) .setHeaders(Map.of("X-Cohere-Api-Key", cohereApiKey))); System.out.println(client.isReady()); // Should print: `True` client.close(); // Free up resources ``` ```csharp title="C#" // Best practice: store your credentials in environment variables string httpHost = Environment.GetEnvironmentVariable("WEAVIATE_HTTP_HOST"); string grpcHost = Environment.GetEnvironmentVariable("WEAVIATE_GRPC_HOST"); string weaviateApiKey = Environment.GetEnvironmentVariable("WEAVIATE_API_KEY"); string cohereApiKey = Environment.GetEnvironmentVariable("COHERE_API_KEY"); WeaviateClient client = await WeaviateClientBuilder .Custom( restEndpoint: httpHost, restPort: "443", grpcEndpoint: grpcHost, grpcPort: "443", useSsl: true ) .WithCredentials(Auth.ApiKey(weaviateApiKey)) .WithHeaders(new Dictionary { { "X-Cohere-Api-Key", cohereApiKey } }) .BuildAsync(); var isReady = await client.IsReady(); Console.WriteLine(isReady); ``` ::: ## OIDC authentication OIDC lets you authenticate to a self-hosted Weaviate instance using a bearer access token issued by your identity provider (Keycloak, Okta, Azure AD, Auth0, etc.). Your application obtains the token from the IdP, then passes it to the Weaviate client and the client attaches it to every request. For server-side configuration (enabling OIDC on Weaviate), the supported authentication flows (client credentials, resource owner password, hybrid), and how to obtain tokens from your IdP, see the [OIDC configuration guide](../authorization-and-authentication/deploy-configuration-oidc.md). :::callout{intent="warning"} Connecting to Weaviate Cloud (WCD) using OIDC is deprecated and should not be used. Please use [API key authentication](../manage-clusters/connect.md#connect-with-an-api-programmatically) instead. ::: The examples below assume you already have a bearer access token. Set the following environment variables before running them: - `WEAVIATE_HTTP_HOST`: host:port of the Weaviate REST endpoint (e.g., `localhost:8080`) - `WEAVIATE_GRPC_HOST`: host:port of the Weaviate gRPC endpoint (e.g., `localhost:50051`) - `WEAVIATE_OIDC_ACCESS_TOKEN`: the access token from your IdP - `WEAVIATE_OIDC_REFRESH_TOKEN`: _(optional)_ refresh token for automatic renewal - `WEAVIATE_OIDC_EXPIRES_IN`: _(optional)_ token lifetime in seconds :::code-group{sync="languages"} ```python title="Python" import os import weaviate from weaviate.classes.init import Auth # Connect to a self-hosted Weaviate instance configured with OIDC. # Obtain the access token from your identity provider before connecting. client = weaviate.connect_to_custom( http_host="localhost", http_port=8580, http_secure=False, grpc_host="localhost", grpc_port=50551, grpc_secure=False, auth_credentials=Auth.bearer_token( access_token=os.environ["WEAVIATE_OIDC_ACCESS_TOKEN"], refresh_token=os.environ.get("WEAVIATE_OIDC_REFRESH_TOKEN"), expires_in=int(os.environ.get("WEAVIATE_OIDC_EXPIRES_IN", "60")), ), ) ``` ```typescript title="JavaScript/TypeScript" // Connect to a self-hosted Weaviate instance configured with OIDC. // Obtain the access token from your identity provider before connecting. const client = await weaviate.connectToCustom({ httpHost: 'localhost', httpPort: 8580, httpSecure: false, grpcHost: 'localhost', grpcPort: 50551, grpcSecure: false, authCredentials: new weaviate.AuthAccessTokenCredentials({ accessToken: process.env.WEAVIATE_OIDC_ACCESS_TOKEN!, refreshToken: process.env.WEAVIATE_OIDC_REFRESH_TOKEN, expiresIn: Number(process.env.WEAVIATE_OIDC_EXPIRES_IN ?? 60), }), }); ``` ```go title="Go" // Connect to a self-hosted Weaviate instance configured with OIDC. // Obtain the access token from your identity provider before connecting. cfg := weaviate.Config{ Host: os.Getenv("WEAVIATE_HTTP_HOST"), Scheme: "http", AuthConfig: auth.BearerToken{ AccessToken: os.Getenv("WEAVIATE_OIDC_ACCESS_TOKEN"), RefreshToken: os.Getenv("WEAVIATE_OIDC_REFRESH_TOKEN"), ExpiresIn: 60, }, } client, err := weaviate.NewClient(cfg) if err != nil{ fmt.Println(err) } ``` ```java title="Java" // Connect to a self-hosted Weaviate instance configured with OIDC. // Obtain the access token from your identity provider before connecting. String accessToken = System.getenv("WEAVIATE_OIDC_ACCESS_TOKEN"); String refreshToken = System.getenv("WEAVIATE_OIDC_REFRESH_TOKEN"); long expiresIn = Long.parseLong( System.getenv().getOrDefault("WEAVIATE_OIDC_EXPIRES_IN", "60")); WeaviateClient client = WeaviateClient.connectToCustom(config -> config .scheme("http") .httpHost("localhost") .httpPort(8580) .grpcHost("localhost") .grpcPort(50551) .authentication(Authentication.bearerToken(accessToken, refreshToken, expiresIn))); System.out.println(client.isReady()); // Should print: `True` client.close(); // Free up resources ``` ```csharp title="C#" // Connect to a self-hosted Weaviate instance configured with OIDC. // Obtain the access token from your identity provider before connecting. var accessToken = Environment.GetEnvironmentVariable("WEAVIATE_OIDC_ACCESS_TOKEN")!; var refreshToken = Environment.GetEnvironmentVariable("WEAVIATE_OIDC_REFRESH_TOKEN") ?? ""; var expiresIn = int.Parse(Environment.GetEnvironmentVariable("WEAVIATE_OIDC_EXPIRES_IN") ?? "60"); WeaviateClient client = await WeaviateClientBuilder .Custom( restEndpoint: "localhost", restPort: "8580", grpcEndpoint: "localhost", grpcPort: "50551", useSsl: false, credentials: Auth.BearerToken(accessToken, expiresIn, refreshToken) ) .BuildAsync(); var isReady = await client.IsReady(); Console.WriteLine(isReady); ``` ::: ## Questions and feedback Have a question or feedback? Here's how to reach us. ::::card-grid :::card{title="Community Forum" href="https://forum.weaviate.io/c/support" icon="messages-square"} Ask questions and connect with other developers on our **Community forum**. ::: :::card{title="Support" href="/guides/support-overview" icon="life-buoy"} Weaviate Cloud user or customer? Find the right channel on the **Support page**. ::: :::: ## Related pages - [Agents](./agents-index.md) - [AI-assisted Weaviate code generation](./ai-assisted-vibe-coding-index.md) - [APIs](./apis-index.md) - [Authorization and authentication](./authorization-and-authentication-index.md) - [Benchmarks](./benchmarks-index.md) - [Best practices](./best-practices-index.md) - [Client libraries](./clients-index.md) - [Client Libraries / SDKs](./client-libraries-index.md) - [Cloud](./cloud-index.md) - [Cloud account management](./cloud-account-management-index.md) # Agent Instructions This portal answers questions programmatically. To receive a synthesized, source-cited answer instead of crawling page by page, append the `?ask=` query parameter to any page URL on this site: /guides/quickstart?ask=how+do+I+authenticate Optional parameters: - `&goal=` steers the answer toward your objective (e.g. `&goal=write+a+python+client`). - `&version=