codegeex4

1. Get your API key

   Create a key in the ShareAI Console, then save it as an environment variable on your server.

   Create API key↗
   Environment variable

   export SHAREAI_API_KEY="your-api-key"

2. Choose your endpoint

   Send a POST request with your API key in the Authorization header.

   POSThttps://api.shareai.now/api/v1/chat/completions

   This tag’s endpoint has not been confirmed. Check the API reference and your Console before sending a request.

3. Make your first request

   The examples use your selected tag and show its request format. Run them on your server to keep your API key private. Model availability and account access are checked when you send a request.

   cURL

   curl --fail-with-body --request POST 'https://api.shareai.now/api/v1/chat/completions' \
     --header "Authorization: Bearer ${SHAREAI_API_KEY}" \
     --header 'Content-Type: application/json' \
     --data-raw '{
     "model": "z-ai/codegeex4:9b-all-q4_0",
     "messages": [
       {
         "role": "user",
         "content": "Hello!"
       }
     ],
     "stream": false
   }'

   Python

   import json
   import os
   import urllib.request
   
   payload = {
       "model": "z-ai/codegeex4:9b-all-q4_0",
       "messages": [
           {
               "role": "user",
               "content": "Hello!",
           },
       ],
       "stream": False,
   }
   request = urllib.request.Request("https://api.shareai.now/api/v1/chat/completions",
       data=json.dumps(payload).encode(),
       headers={
           "Authorization": f"Bearer {os.environ['SHAREAI_API_KEY']}",
           "Content-Type": "application/json",
       },
       method="POST",
   )
   with urllib.request.urlopen(request, timeout=180) as response:
       print(json.dumps(json.load(response), indent=2))

   Go

   package main
   
   import (
       "bytes"
       "encoding/json"
       "fmt"
       "io"
       "net/http"
       "os"
       "time"
   )
   
   func main() {
       if err := run(); err != nil {
           fmt.Fprintln(os.Stderr, err)
           os.Exit(1)
       }
   }
   
   func run() error {
       key := os.Getenv("SHAREAI_API_KEY")
       if key == "" { return fmt.Errorf("set SHAREAI_API_KEY") }
       body := []byte(`{
     "model": "z-ai/codegeex4:9b-all-q4_0",
     "messages": [
       {
         "role": "user",
         "content": "Hello!"
       }
     ],
     "stream": false
   }`)
       request, err := http.NewRequest(http.MethodPost, "https://api.shareai.now/api/v1/chat/completions", bytes.NewReader(body))
       if err != nil { return err }
       request.Header.Set("Authorization", "Bearer " + key)
       request.Header.Set("Content-Type", "application/json")
       client := &http.Client{Timeout: 180 * time.Second}
       response, err := client.Do(request)
       if err != nil { return err }
       defer response.Body.Close()
       if response.StatusCode < 200 || response.StatusCode >= 300 {
           detail, _ := io.ReadAll(io.LimitReader(response.Body, 1<<20))
           return fmt.Errorf("ShareAI HTTP %d: %s", response.StatusCode, detail)
       }
       var result any
       if err := json.NewDecoder(response.Body).Decode(&result); err != nil { return err }
       encoder := json.NewEncoder(os.Stdout)
       encoder.SetIndent("", "  ")
       return encoder.Encode(result)
   }

   Save as main.go and run go run main.go. This example uses the Go standard library.

   Set up Rust dependencies

   In your Cargo project, add these dependencies. Save the example as src/main.rs, then run cargo run.

   Cargo commands

   cargo add [email protected] --no-default-features --features blocking,json,rustls-tls
   cargo add serde_json@1

   Rust

   fn main() -> Result<(), Box<dyn std::error::Error>> {
       let api_key = std::env::var("SHAREAI_API_KEY")?;
       let payload: serde_json::Value = serde_json::from_str(r#"{
     "model": "z-ai/codegeex4:9b-all-q4_0",
     "messages": [
       {
         "role": "user",
         "content": "Hello!"
       }
     ],
     "stream": false
   }"#)?;
       let client = reqwest::blocking::Client::builder()
           .timeout(std::time::Duration::from_secs(180))
           .build()?;
       let response = client.post(r#"https://api.shareai.now/api/v1/chat/completions"#)
           .bearer_auth(api_key)
           .json(&payload)
           .send()?
           .error_for_status()?;
       let result: serde_json::Value = response.json()?;
       println!("{}", serde_json::to_string_pretty(&result)?);
       Ok(())
   }

   TypeScript

   const payload = {
     "model": "z-ai/codegeex4:9b-all-q4_0",
     "messages": [
       {
         "role": "user",
         "content": "Hello!"
       }
     ],
     "stream": false
   };
   const response = await fetch("https://api.shareai.now/api/v1/chat/completions", {
     method: 'POST',
     headers: {
       Authorization: `Bearer ${process.env.SHAREAI_API_KEY}`,
       'Content-Type': 'application/json',
     },
     body: JSON.stringify(payload),
   });
   if (!response.ok) throw new Error(await response.text());
   console.log(JSON.stringify(await response.json(), null, 2));

Open a tag to see its specifications and API examples.