Z.AI provides standard HTTP API interfaces that support multiple programming languages and development environments, allowing you to easily integrate Z.AI’s powerful capabilities.
Core Advantages
Cross-platform Compatible Supports all programming languages and platforms that support HTTP protocol
Standard Protocol Based on RESTful design, follows HTTP standards, easy to understand and use
Flexible Integration Can be integrated into any existing applications and systems
Real-time Calls Supports synchronous and asynchronous calls to meet different scenario requirements
Get API Key
Access Z.AI Open Platform , Register or Login.
Create an API Key in the API Keys management page.
Copy your API Key for use.
General API Endpoint
https://api.z.ai/api/paas/v4/
Content-Type : application/json
Authorization : Bearer YOUR_API_KEY
Supported Authentication Methods
API Key Authentication
JWT Token Authentication
The simplest authentication method, directly using your API Key: curl --location 'https://api.z.ai/api/paas/v4/chat/completions' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'Accept-Language: en-US,en' \
--header 'Content-Type: application/json' \
--data '{
"model": "glm-4.6",
"messages": [
{
"role": "user",
"content": "Hello"
}
]
}'
Use JWT Token for authentication, suitable for scenarios requiring higher security:
Install PyJWT import time
import jwt
def generate_token ( apikey : str , exp_seconds : int ):
try :
id , secret = apikey.split( "." )
except Exception as e:
raise Exception ( "invalid apikey" , e)
payload = {
"api_key" : id ,
"exp" : int ( round (time.time() * 1000 )) + exp_seconds * 1000 ,
"timestamp" : int ( round (time.time() * 1000 )),
}
return jwt.encode(
payload,
secret,
algorithm = "HS256" ,
headers = { "alg" : "HS256" , "sign_type" : "SIGN" },
)
# Use the generated token
token = generate_token( "your-api-key" , 3600 ) # 1 hour validity
Basic Call Examples
Simple Conversation
curl --location 'https://api.z.ai/api/paas/v4/chat/completions' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'Accept-Language: en-US,en' \
--header 'Content-Type: application/json' \
--data '{
"model": "glm-4.6",
"messages": [
{
"role": "user",
"content": "Please introduce the development history of artificial intelligence"
}
],
"temperature": 1.0,
"max_tokens": 1024
}'
Streaming Response
curl --location 'https://api.z.ai/api/paas/v4/chat/completions' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'Accept-Language: en-US,en' \
--header 'Content-Type: application/json' \
--data '{
"model": "glm-4.6",
"messages": [
{
"role": "user",
"content": "Write a poem about spring"
}
],
"stream": true
}'
Multi-turn Conversation
curl --location 'https://api.z.ai/api/paas/v4/chat/completions' \
--header 'Authorization: Bearer YOUR_API_KEY' \
--header 'Accept-Language: en-US,en' \
--header 'Content-Type: application/json' \
--data '{
"model": "glm-4.6",
"messages": [
{
"role": "system",
"content": "You are a professional programming assistant"
},
{
"role": "user",
"content": "What is recursion?"
},
{
"role": "assistant",
"content": "Recursion is a programming technique where a function calls itself to solve problems..."
},
{
"role": "user",
"content": "Can you give me an example of Python recursion?"
}
]
}'
Common Programming Language Examples
import requests
import json
def call_zai_api ( messages , model = "glm-4.6" ):
url = "https://api.z.ai/api/paas/v4/chat/completions"
headers = {
"Authorization" : "Bearer YOUR_API_KEY" ,
"Content-Type" : "application/json" ,
"Accept-Language" : "en-US,en"
}
data = {
"model" : model,
"messages" : messages,
"temperature" : 1.0
}
response = requests.post(url, headers = headers, json = data)
if response.status_code == 200 :
return response.json()
else :
raise Exception ( f "API call failed: { response.status_code } , { response.text } " )
# Usage example
messages = [
{ "role" : "user" , "content" : "Hello, please introduce yourself" }
]
result = call_zai_api(messages)
print (result[ 'choices' ][ 0 ][ 'message' ][ 'content' ])
async function callZAPI ( messages , model = 'glm-4.6' ) {
const url = 'https://api.z.ai/api/paas/v4/chat/completions' ;
const response = await fetch ( url , {
method: 'POST' ,
headers: {
'Authorization' : 'Bearer YOUR_API_KEY' ,
'Content-Type' : 'application/json' ,
'Accept-Language' : 'en-US,en'
},
body: JSON . stringify ({
model: model ,
messages: messages ,
temperature: 1.0
})
});
if ( ! response . ok ) {
throw new Error ( `API call failed: ${ response . status } ` );
}
return await response . json ();
}
// Usage example
const messages = [
{ role: 'user' , content: 'Hello, please introduce yourself' }
];
callZAPI ( messages )
. then ( result => {
console . log ( result . choices [ 0 ]. message . content );
})
. catch ( error => {
console . error ( 'Error:' , error );
});
import com.fasterxml.jackson.databind.ObjectMapper;
import okhttp3.MediaType;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
public class AgentExample {
public static void main ( String [] args ) throws Exception {
OkHttpClient client = new OkHttpClient ();
ObjectMapper mapper = new ObjectMapper ();
Map < String , String > messages = new HashMap <>( 8 );
messages . put ( "role" , "user" );
messages . put ( "content" , "Hello, please introduce yourself" );
Map < String , Object > requestBody = new HashMap <>();
requestBody . put ( "model" , "glm-4.6" );
requestBody . put ( "messages" , Collections . singletonList (messages));
requestBody . put ( "temperature" , 1.0 );
String jsonBody = mapper . writeValueAsString (requestBody);
MediaType JSON = MediaType . get ( "application/json; charset=utf-8" );
RequestBody body = RequestBody . create (JSON, jsonBody);
Request request = new Request. Builder ()
. url ( "https://api.z.ai/api/paas/v4/chat/completions" )
. addHeader ( "Authorization" , "Bearer your_api_key" )
. addHeader ( "Content-Type" , "application/json" )
. addHeader ( "Accept-Language" , "en-US,en" )
. post (body)
. build ();
try ( Response response = client . newCall (request). execute ()) {
System . out . println ( response . body (). string ());
}
}
}
Best Practices
Security
Properly secure API Keys, do not hard-code them in your code
Use environment variables or configuration files to store sensitive information
Regularly rotate API Keys
Performance Optimization
Implement connection pooling and session reuse
Set reasonable timeout values
Use asynchronous requests for high-concurrency scenarios
Error Handling
Implement exponential backoff retry mechanisms
Log detailed error information
Set reasonable timeout and retry limits
Monitoring
Monitor API call frequency and success rates
Track response times and error rates
Set up alerting mechanisms
Get More
It is recommended to use HTTPS protocol in production environments and implement appropriate security measures to protect your API keys and data transmission.