Support for the official ChatGPT model has been added! You can now use the gpt-3.5-turbo model with the official OpenAI API, using ChatGPTClient. This is the same model that ChatGPT uses, and it's the most powerful model available right now. Usage of this model is not free, however it is 10x cheaper (priced at $0.002 per 1k tokens) than text-davinci-003.

See OpenAI's post, Introducing ChatGPT and Whisper APIs for more information.

~~To use it, set modelOptions.model to gpt-3.5-turbo, and ChatGPTClient will handle the rest.~~
The default model used in ChatGPTClient is now gpt-3.5-turbo.
You can still set userLabel, chatGptLabel and promptPrefix (system instructions) as usual.

There may be a higher chance of your account being banned if you continue to automate chat.openai.com. Continue doing so at your own risk.

See demos/use-bing-client.js.


See demos/use-client.js.


See demos/use-browser-client.js.


`JS
module.exports = {
// Options for the Keyv cache, see https://www.npmjs.com/package/keyv.
// This is used for storing conversations, and supports additional drivers (conversations are stored in memory by default).
// Only necessary when using ChatGPTClient, or BingAIClient in jailbreak mode.
cacheOptions: {},
// If set, ChatGPTClient and BingAIClient will use keyv-file to store conversations to this JSON file instead of in memory.
// However, cacheOptions.store will override this if set
storageFilePath: process.env.STORAGE_FILE_PATH || './cache.json',
chatGptClient: {
// Your OpenAI API key (for ChatGPTClient)
openaiApiKey: process.env.OPENAI_API_KEY || '',
// (Optional) Support for a reverse proxy for the completions endpoint (private API server).
// Warning: This will expose your openaiApiKey to a third party. Consider the risks before using this.
// reverseProxyUrl: 'https://chatgpt.hato.ai/completions',
// (Optional) Parameters as described in https://platform.openai.com/docs/api-reference/completions
modelOptions: {
// You can override the model name and any other parameters here.
// The default model is gpt-3.5-turbo.
model: 'gpt-3.5-turbo',
// Set max_tokens here to override the default max_tokens of 1000 for the completion.
// max_tokens: 1000,
},
// (Optional) Davinci models have a max context length of 4097 tokens, but you may need to change this for other models.
// maxContextTokens: 4097,
// (Optional) You might want to lower this to save money if using a paid model like text-davinci-003.
// Earlier messages will be dropped until the prompt is within the limit.
// maxPromptTokens: 3097,
// (Optional) Set custom instructions instead of "You are ChatGPT...".
// (Optional) Set a custom name for the user
// userLabel: 'User',
// (Optional) Set a custom name for ChatGPT ("ChatGPT" by default)
// chatGptLabel: 'Bob',
// promptPrefix: 'You are Bob, a cowboy in Western times...',
// A proxy string like "http://:"
proxy: '',
// (Optional) Set to true to enable console.debug() logging
debug: false,
},
// Options for the Bing client
bingAiClient: {
// Necessary for some people in different countries, e.g. China (https://cn.bing.com)
host: '',
// The "_U" cookie value from bing.com
userToken: '',
// If the above doesn't work, provide all your cookies as a string instead
cookies: '',
// A proxy string like "http://:"
proxy: '',
// (Optional) Set to true to enable console.debug() logging
debug: false,
},
chatGptBrowserClient: {
// (Optional) Support for a reverse proxy for the conversation endpoint (private API server).
// Warning: This will expose your access token to a third party. Consider the risks before using this.
reverseProxyUrl: 'https://bypass.churchless.tech/api/conversation',
// Access token from https://chat.openai.com/api/auth/session
accessToken: '',
// Cookies from chat.openai.com (likely not required if using reverse proxy server).
cookies: '',
// A proxy string like "http://:"
proxy: '',
// (Optional) Set to true to enable console.debug() logging
debug: false,
},
// Options for the API server
apiOptions: {
port: process.env.API_PORT || 3000,
host: process.env.API_HOST || 'localhost',
// (Optional) Set to true to enable console.debug() logging
debug: false,
// (Optional) Possible options: "chatgpt", "chatgpt-browser", "bing". (Default: "chatgpt")
clientToUse: 'chatgpt',
// (Optional) Generate titles for each conversation for clients that support it (only ChatGPTClient for now).
// This will be returned as a title property in the first response of the conversation.
generateTitles: false,
// (Optional) Set this to allow changing the client or client options in POST /conversation.
// To disable, set to null.
perMessageClientOptionsWhitelist: {
// The ability to switch clients using clientOptions.clientToUse will be disabled if validClientsToUse is not set.
// To allow switching clients per message, you must set validClientsToUse to a non-empty array.
validClientsToUse: ['bing', 'chatgpt', 'chatgpt-browser'], // values from possible clientToUse options above
// The Object key, e.g. "chatgpt", is a value from validClientsToUse.
// If not set, ALL options will be ALLOWED to be changed. For example, bing is not defined in perMessageClientOptionsWhitelist above,
// so all options for bingAiClient will be allowed to be changed.
// If set, ONLY the options listed here will be allowed to be changed.
// In this example, each array element is a string representing a property in chatGptClient above.
chatgpt: [
'promptPrefix',
'userLabel',
'chatGptLabel',
// Setting modelOptions.temperature here will allow changing ONLY the temperature.
// Other options like modelOptions.model will not be allowed to be changed.
// If you want to allow changing all modelOptions, define modelOptions here instead of modelOptions.temperature.
'modelOptions.temperature',
],
},
},
// Options for the CLI app
cliOptions: {
// (Optional) Possible options: "chatgpt", "bing".
// clientToUse: 'bing',
},
};
`


| Field | Description |
|---------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| message | The message to be displayed to the user. |
| conversationId | (Optional) An ID for the conversation you want to continue. |
| jailbreakConversationId | (Optional, for BingAIClient only) Set to true to start a conversation in jailbreak mode. After that, this should be the ID for the jailbreak conversation (given in the response as a parameter also named jailbreakConversationId). |
| parentMessageId | (Optional, for ChatGPTClient, and BingAIClient in jailbreak mode) The ID of the parent message (i.e. response.messageId) when continuing a conversation. |
| conversationSignature | (Optional, for BingAIClient only) A signature for the conversation (given in the response as a parameter also named conversationSignature). Required when continuing a conversation unless in jailbreak mode. |
| clientId | (Optional, for BingAIClient only) The ID of the client. Required when continuing a conversation unless in jailbreak mode. |
| invocationId | (Optional, for BingAIClient only) The ID of the invocation. Required when continuing a conversation unless in jailbreak mode. |
| clientOptions | (Optional) An object containing options for the client. |
| clientOptions.clientToUse | (Optional) The client to use for this message. Possible values: chatgpt, chatgpt-browser, bing. |
| clientOptions.* | (Optional) Any valid options for the client. For example, for ChatGPTClient, you can set clientOptions.openaiApiKey to set an API key for this message only, or clientOptions.promptPrefix to give the AI custom instructions for this message only, etc. |

To configure which options can be changed per message (default: all), see the comments for perMessageClientOptionsWhitelist in settings.example.js.
To allow changing clients, perMessageClientOptionsWhitelist.validClientsToUse must be set to a non-empty array as described in the example settings file.


To start a conversation with ChatGPT, send a POST request to the server's /conversation endpoint with a JSON body with parameters per Endpoints > POST /conversation above.
`JSON
{
"message": "Hello, how are you today?",
"conversationId": "your-conversation-id (optional)",
"parentMessageId": "your-parent-message-id (optional, for ChatGPTClient only)",
"conversationSignature": "your-conversation-signature (optional, for BingAIClient only)",
"clientId": "your-client-id (optional, for BingAIClient only)",
"invocationId": "your-invocation-id (optional, for BingAIClient only)",
}
`
The server will return a JSON object containing ChatGPT's response:
`JS
// HTTP/1.1 200 OK
{
"response": "I'm doing well, thank you! How are you?",
"conversationId": "your-conversation-id",
"messageId": "response-message-id (for ChatGPTClient only)",
"conversationSignature": "your-conversation-signature (for BingAIClient only)",
"clientId": "your-client-id (for BingAIClient only)",
"invocationId": "your-invocation-id (for BingAIClient only - pass this new value back into subsequent requests as-is)",
"details": "an object containing the raw response from the client"
}
`

If the request is unsuccessful, the server will return a JSON object with an error message.

If the request object is missing a required property (e.g. message):
`JS
// HTTP/1.1 400 Bad Request
{
"error": "The message parameter is required."
}
`
If there was an error sending the message to ChatGPT:
`JS
// HTTP/1.1 503 Service Unavailable
{
"error": "There was an error communicating with ChatGPT."
}
`


You can set "stream": true in the request body to receive a stream of tokens as they are generated.

`js
import { fetchEventSource } from '@waylaidwanderer/fetch-event-source'; // use @microsoft/fetch-event-source instead if in a browser environment

const opts = {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
body: JSON.stringify({
"message": "Write a poem about cats.",
"conversationId": "your-conversation-id (optional)",
"parentMessageId": "your-parent-message-id (optional)",
"stream": true,
// Any other parameters per Endpoints > POST /conversation above
}),
};
`

See demos/use-api-server-streaming.js for an example of how to receive the response as it's generated. You will receive one token at a time, so you will need to concatenate them yourself.

Successful output:
`JS
{ data: '', event: '', id: '', retry: 3000 }
{ data: 'Hello', event: '', id: '', retry: undefined }
{ data: '!', event: '', id: '', retry: undefined }
{ data: ' How', event: '', id: '', retry: undefined }
{ data: ' can', event: '', id: '', retry: undefined }
{ data: ' I', event: '', id: '', retry: undefined }
{ data: ' help', event: '', id: '', retry: undefined }
{ data: ' you', event: '', id: '', retry: undefined }
{ data: ' today', event: '', id: '', retry: undefined }
{ data: '?', event: '', id: '', retry: undefined }
{ data: '', event: 'result', id: '', retry: undefined }
{ data: '[DONE]', event: '', id: '', retry: undefined }
// Hello! How can I help you today?
`

Error output:
`JS
const message = {
data: '{"code":503,"error":"There was an error communicating with ChatGPT."}',
event: 'error',
id: '',
retry: undefined
};

if (message.event === 'error') {
console.error(JSON.parse(message.data).error); // There was an error communicating with ChatGPT.
}
`


How does it work? Simple answer: ChatGPTClient > reverse proxy > OpenAI server. The reverse proxy server does some magic under the hood to access the underlying model directly via OpenAI's server and then returns the response to ChatGPTClient.

Instructions are provided below.