# Démarrer avec DimaRouter

1. Créez un compte et une clé sur https://dimarouter.ma/#/app/keys (ou via l’outil MCP `create_account`).
2. Rechargez votre solde en DH (carte bancaire, sans abonnement).
3. Appelez l’API compatible OpenAI :

- **Base URL** : `https://api.dimarouter.ma/v1`
- **Authentification** : `Authorization: Bearer $DIMA_API_KEY` (clés `dima_live_…`)
- **Endpoints** : `/chat/completions` (OpenAI), `/responses` (OpenAI Responses), `/messages` (Anthropic Messages), `/batches`, `/models`
- **Spécification** : https://dimarouter.ma/openapi.json

### Python

```python
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.dimarouter.ma/v1",
    api_key=os.environ["DIMA_API_KEY"],
)

response = client.chat.completions.create(
    model="zai-org/GLM-5.3-Flash",
    messages=[{"role": "user", "content": "Salam"}],
)
print(response.choices[0].message.content)
```

### JavaScript / TypeScript

```ts
import OpenAI from "openai"

const client = new OpenAI({
  baseURL: "https://api.dimarouter.ma/v1",
  apiKey: process.env.DIMA_API_KEY ?? "",
})

const response = await client.chat.completions.create({
  model: "zai-org/GLM-5.3-Flash",
  messages: [{ role: "user", content: "Salam" }],
})
console.log(response.choices[0].message.content)
```

### PHP

```php
<?php
$client = curl_init("https://api.dimarouter.ma/v1/chat/completions");
curl_setopt_array($client, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Content-Type: application/json',
        'Authorization: Bearer ' . getenv('DIMA_API_KEY'),
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'model' => 'zai-org/GLM-5.3-Flash',
        'messages' => [['role' => 'user', 'content' => 'Salam']],
    ]),
]);
$response = curl_exec($client);
if ($response === false) {
    throw new RuntimeException(curl_error($client));
}
curl_close($client);
echo $response;
```

### Go

```go
package main

import (
    "fmt"
    "io"
    "net/http"
    "os"
    "strings"
)

func main() {
    body := strings.NewReader(`{"model":"zai-org/GLM-5.3-Flash","messages":[{"role":"user","content":"Salam"}]}`)
    request, err := http.NewRequest("POST", "https://api.dimarouter.ma/v1/chat/completions", body)
    if err != nil { panic(err) }
    request.Header.Set("Authorization", "Bearer "+os.Getenv("DIMA_API_KEY"))
    request.Header.Set("Content-Type", "application/json")

    response, err := http.DefaultClient.Do(request)
    if err != nil { panic(err) }
    defer response.Body.Close()
    result, err := io.ReadAll(response.Body)
    if err != nil { panic(err) }
    if response.StatusCode >= 400 { panic(string(result)) }
    fmt.Println(string(result))
}
```

### Java

```java
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
    public static void main(String[] args) throws Exception {
        String body = """
            {"model":"zai-org/GLM-5.3-Flash",
             "messages":[{"role":"user","content":"Salam"}]}
            """;
        var request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.dimarouter.ma/v1/chat/completions"))
            .header("Authorization", "Bearer " + System.getenv("DIMA_API_KEY"))
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(body))
            .build();
        var response = HttpClient.newHttpClient()
            .send(request, HttpResponse.BodyHandlers.ofString());
        if (response.statusCode() >= 400) throw new RuntimeException(response.body());
        System.out.println(response.body());
    }
}
```

### C# / .NET

```csharp
using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;

using var client = new HttpClient();
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(
    "Bearer", Environment.GetEnvironmentVariable("DIMA_API_KEY"));

using var body = new StringContent(
    """{"model":"zai-org/GLM-5.3-Flash","messages":[{"role":"user","content":"Salam"}]}""",
    Encoding.UTF8, "application/json");
using var response = await client.PostAsync(
    "https://api.dimarouter.ma/v1/chat/completions", body);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());
```

### Ruby

```ruby
require "net/http"
require "json"

url = URI("https://api.dimarouter.ma/v1/chat/completions")
request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer #{ENV.fetch('DIMA_API_KEY')}"
request["Content-Type"] = "application/json"
request.body = JSON.generate(
  model: "zai-org/GLM-5.3-Flash",
  messages: [{ role: "user", content: "Salam" }]
)
response = Net::HTTP.start(url.hostname, url.port, use_ssl: true) do |http|
  http.request(request)
end
raise response.body unless response.is_a?(Net::HTTPSuccess)
puts JSON.parse(response.body).dig("choices", 0, "message", "content")
```

### Rust

```rust
// cargo add reqwest --features json
// cargo add tokio --features macros,rt-multi-thread
// cargo add serde_json

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let response = reqwest::Client::new()
        .post("https://api.dimarouter.ma/v1/chat/completions")
        .bearer_auth(std::env::var("DIMA_API_KEY")?)
        .json(&serde_json::json!({
            "model": "zai-org/GLM-5.3-Flash",
            "messages": [{"role": "user", "content": "Salam"}]
        }))
        .send().await?
        .error_for_status()?
        .json::<serde_json::Value>().await?;
    println!("{}", response["choices"][0]["message"]["content"]);
    Ok(())
}
```

### cURL

```bash
curl --fail-with-body https://api.dimarouter.ma/v1/chat/completions \
  -H "Authorization: Bearer $DIMA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "zai-org/GLM-5.3-Flash",
    "messages": [{"role": "user", "content": "Salam"}]
  }'
```
