---
title: "Authorize Existing Tools"
description: "Use Arcade to authorize existing tools"
---

import { Steps, Tabs, Callout } from "nextra/components";

## Authorize Existing Tools

In this guide, we'll show you how to authorize LangChain tools like the `GmailToolkit` using Arcade. You may already have tools you want to use, and this guide will show you how to authorize them. Arcade handles retrieving, authorizing, and managing tokens so you don't have to. For complete working examples, see our [Python](https://github.com/ArcadeAI/arcade-ai/blob/main/examples/langchain/langchain_tool_arcade_auth.py) and [JavaScript](https://github.com/ArcadeAI/arcade-ai/blob/main/examples/langchain-ts/langchain-tool-arcade-auth.ts) examples.

<Steps>

### Prerequisites

- [Obtain an Arcade API key](/get-started/setup/api-keys)

### Install the required packages

Instead of the `langchain_arcade` package, you only need the `arcadepy` package to authorize existing tools since Arcade tools are not being used.

<Tabs items={["Python", "JavaScript"]} storageKey="preferredLanguage">
<Tabs.Tab>
```bash
pip install langchain-openai langgraph arcadepy langchain-google-community
```
</Tabs.Tab>
<Tabs.Tab>
```bash
npm install @arcadeai/arcadejs @langchain/openai @langchain/core @langchain/langgraph @langchain/community
```
</Tabs.Tab>
</Tabs>
### Import the necessary packages

<Tabs items={["Python", "JavaScript"]} storageKey="preferredLanguage">
<Tabs.Tab>
```python
import os
from arcadepy import Arcade
from google.oauth2.credentials import Credentials
from langchain_google_community import GmailToolkit
from langchain_google_community.gmail.utils import build_resource_service
from langchain_openai import ChatOpenAI
from langgraph.prebuilt import create_react_agent
```
</Tabs.Tab>
<Tabs.Tab>
```javascript
import { Arcade } from "@arcadeai/arcadejs";
import {
	GmailCreateDraft,
	GmailGetMessage,
	GmailGetThread,
	GmailSearch,
	GmailSendMessage,
} from "@langchain/community/tools/gmail";
import type { StructuredTool } from "@langchain/core/tools";
import { createReactAgent } from "@langchain/langgraph/prebuilt";
import { ChatOpenAI } from "@langchain/openai";
```
</Tabs.Tab>
</Tabs>
### Initialize the Arcade client

<Tabs items={["Python", "JavaScript"]} storageKey="preferredLanguage">
<Tabs.Tab>
```python
api_key = os.getenv("ARCADE_API_KEY")
client = Arcade(api_key=api_key)
```
</Tabs.Tab>
<Tabs.Tab>
```javascript
const arcade = new Arcade();
```
</Tabs.Tab>
</Tabs>

### Start the authorization process for Gmail

<Tabs items={["Python", "JavaScript"]} storageKey="preferredLanguage">
<Tabs.Tab>
```python
user_id = "{arcade_user_id}"
auth_response = client.auth.start(
    user_id=user_id,
    provider="google",
    scopes=["https://www.googleapis.com/auth/gmail.readonly"],
)
```
</Tabs.Tab>
<Tabs.Tab>
```javascript
const USER_ID = "{arcade_user_id}";
const authResponse = await arcade.auth.start(USER_ID, "google", {
	scopes: ["https://www.googleapis.com/auth/gmail.readonly"],
});

```
</Tabs.Tab>
</Tabs>

### Prompt the user to authorize

<Tabs items={["Python", "JavaScript"]} storageKey="preferredLanguage">
<Tabs.Tab>
```python
if auth_response.status != "completed":
    print("Please authorize the application in your browser:")
    print(auth_response.url)
```

The `auth_response.status` will be `"completed"` if the user has already authorized the application, so they won't be prompted to authorize again.
</Tabs.Tab>
<Tabs.Tab>
```javascript
if (authResponse.status !== "completed") {
	console.log("Please authorize the application in your browser:");
	console.log(authResponse.url);
}
```

The `authResponse.status` will be `"completed"` if the user has already authorized the application, so they won't be prompted to authorize again.
</Tabs.Tab>
</Tabs>


### Wait for authorization completion

<Tabs items={["Python", "JavaScript"]} storageKey="preferredLanguage">
<Tabs.Tab>
```python
auth_response = client.auth.wait_for_completion(auth_response)
```

The `wait_for_completion` method will do nothing if the user has already authorized the application.
</Tabs.Tab>
<Tabs.Tab>
```javascript
const completedAuth = await arcade.auth.waitForCompletion(authResponse);
```

The `waitForCompletion` method will do nothing if the user has already authorized the application.
</Tabs.Tab>
</Tabs>


### Use the token to initialize the Gmail MCP Server

<Tabs items={["Python", "JavaScript"]} storageKey="preferredLanguage">
<Tabs.Tab>
```python
creds = Credentials(auth_response.context.token)
api_resource = build_resource_service(credentials=creds)
toolkit = GmailToolkit(api_resource=api_resource)
tools = toolkit.get_tools()
```
</Tabs.Tab>
<Tabs.Tab>
```javascript
const gmailParam = {
	credentials: {
		accessToken: completedAuth.context.token,
	},
};
const tools: StructuredTool[] = [
	new GmailCreateDraft(gmailParam),
	new GmailGetMessage(gmailParam),
	new GmailGetThread(gmailParam),
	new GmailSearch(gmailParam),
	new GmailSendMessage(gmailParam),
];
```
</Tabs.Tab>
</Tabs>
### Initialize the agent

<Tabs items={["Python", "JavaScript"]} storageKey="preferredLanguage">
<Tabs.Tab>
```python
model = ChatOpenAI(model="gpt-4o")
agent_executor = create_react_agent(model, tools)
```
</Tabs.Tab>
<Tabs.Tab>
```javascript
const llm = new ChatOpenAI({ model: "gpt-4o" });
const agent_executor = createReactAgent({ llm, tools });
```
</Tabs.Tab>
</Tabs>
### Execute the agent

<Tabs items={["Python", "JavaScript"]} storageKey="preferredLanguage">
<Tabs.Tab>
```python
example_query = "Read my latest emails and summarize them."

events = agent_executor.stream(
    {"messages": [("user", example_query)]},
    stream_mode="values",
)
for event in events:
    event["messages"][-1].pretty_print()
```
</Tabs.Tab>
<Tabs.Tab>
```javascript
const exampleQuery = "Read my latest emails and summarize them.";
const events = await agent_executor.stream({ messages: [ { role: "user", content: exampleQuery } ] }, {	streamMode: "values" } );
for await (const event of events) {
	console.log(event.messages[event.messages.length - 1]);
}
```
</Tabs.Tab>
</Tabs>
</Steps>

### Next Steps

Now you're ready to explore more LangChain tools with Arcade. Try integrating additional MCP Servers and crafting more complex queries to enhance your AI workflows.