> ## Documentation Index
> Fetch the complete documentation index at: https://docs.wandb.ai/llms.txt
> Use this file to discover all available pages before exploring further.
# Interroger et exporter des appels
> Filtrez, triez et exportez les données d’appels Weave à l’aide du SDK Python, de l’API REST ou de l’interface Weave pour une analyse personnalisée.
Cette page vous montre comment interroger et exporter des appels Weave afin d’analyser les données de trace en dehors de Weave. Par exemple, vous pouvez créer des tableaux de bord personnalisés, partager les résultats avec des collaborateurs ou effectuer une analyse hors ligne. Vous pouvez exporter des appels depuis l’interface Weave, les récupérer de manière programmatique avec les SDK Python ou TypeScript, ou les interroger directement à l’aide de l’API de service.
## Exporter des appels depuis l’interface Weave
Dans l’interface Weave, vous pouvez exporter vos données dans plusieurs formats. Elle affiche également le code Python et cURL que vous pouvez utiliser pour exporter les lignes de manière programmatique.
Pour exporter des appels :
1. Accédez à [wandb.ai](https://wandb.ai/) et sélectionnez votre projet.
2. Dans la barre latérale du projet Weave, cliquez sur **Traces**.
3. Sélectionnez plusieurs appels à exporter en cochant la ligne correspondante.
4. Dans la barre d’outils du tableau **Traces**, cliquez sur le bouton d’exportation ou de téléchargement.
5. Dans la fenêtre modale **Export**, choisissez **Selected rows** ou **All rows**.
6. Cliquez sur **Export**.
## Récupérer les appels par programmation
Pour filtrer, trier ou traiter des appels en dehors de l’interface utilisateur, récupérez-les avec l’un des SDK Weave ou l’API de service. Choisissez l’interface qui correspond le mieux à votre flux de travail.
Pour récupérer des appels avec l’API Python, utilisez la méthode [`client.get_calls`](/fr/weave/reference/python-sdk/trace/weave_client#method-get_calls) :
```python lines theme={null}
import weave
# Initialize the client
client = weave.init("your-project-name")
# Fetch calls
calls = client.get_calls(filter=...)
```
Pour récupérer des appels avec l’API TypeScript, utilisez la méthode [`client.getCalls`](/fr/weave/reference/typescript-sdk/classes/weaveclient#getcalls) :
```typescript lines theme={null}
import * as weave from 'weave'
// Initialize the client
const client = await weave.init('intro-example')
// Fetch calls
const calls = await client.getCalls(filter=...)
```
L’API de service expose la couche de requête complète. Pour récupérer des appels avec l’API de service, envoyez une requête au point de terminaison [`/calls/stream_query`](https://docs.wandb.ai/weave/reference/service-api/calls/calls-query-stream) :
```bash theme={null}
curl -L 'https://trace.wandb.ai/calls/stream_query' \
-H 'Content-Type: application/json' \
-H 'Accept: application/json' \
-d '{
"project_id": "string",
"filter": {
"op_names": [
"string"
],
"input_refs": [
"string"
],
"output_refs": [
"string"
],
"parent_ids": [
"string"
],
"trace_ids": [
"string"
],
"call_ids": [
"string"
],
"trace_roots_only": true,
"wb_user_ids": [
"string"
],
"wb_run_ids": [
"string"
]
},
"limit": 100,
"offset": 0,
"sort_by": [
{
"field": "string",
"direction": "asc"
}
],
"query": {
"$expr": {}
},
"include_costs": true,
"include_feedback": true,
"columns": [
"string"
],
"expand_columns": [
"string"
]
}'
```
Pour plus de détails sur les propriétés et les champs des appels, voir la [référence du schéma des appels](/fr/weave/guides/tracking/call-schema-reference).
## Exporter les métriques des appels
Lorsque vous avez besoin de données agrégées, comme des tendances de coût ou de latence, plutôt que des enregistrements d'appels sous-jacents, utilisez le point de terminaison de métriques décrit dans cette section.
Vous pouvez également utiliser le [point de terminaison POST `/calls/stats` de l'API de service Weave](https://docs.wandb.ai/weave/reference/service-api/calls/call-stats) pour récupérer des métriques sur vos appels sans récupérer les données d'appel elles-mêmes. Vous pouvez récupérer des informations sur vos appels, comme la latence et le coût, et les agréger par somme, moyenne, minimum, maximum et nombre. Par exemple, vous pouvez récupérer :
* Utilisation totale des jetons
* Latence moyenne
* Nombre maximal de jetons utilisés
* Coût total
* Nombre minimal de jetons d'entrée
Le point de terminaison propose plusieurs options de filtrage afin de cibler les appels effectués sur des périodes spécifiées, ainsi que selon d'autres propriétés, telles que :
* Nom de l'op
* ID de trace
* ID de thread
* ID d'utilisateur
L'exemple suivant montre comment récupérer les appels générés à partir d'une op nommée `web_app` sur deux jours. Remplacez `[YOUR-TEAM-NAME/YOUR-PROJECT-NAME]` par les noms de votre équipe et de votre projet :
```python Python lines {10-11,16-24} theme={null}
import requests
import json
import os
url = "https://trace.wandb.ai/calls/stats"
payload = {
"project_id": "[YOUR-TEAM-NAME/YOUR-PROJECT-NAME]",
"start": "2026-03-01T00:00:00Z",
# Spécifiez la taille des buckets, en secondes.
"granularity": 86400,
"filter": {
"trace_roots_only": True,
"op_names": ["web_app"]
},
# Spécifiez les métriques et leur fonction d'agrégation
"usage_metrics": [
{"metric": "total_tokens", "aggregations": ["sum"]},
{"metric": "total_cost", "aggregations": ["sum"]}
],
"call_metrics": [
{"metric": "call_count", "aggregations": ["sum"]},
{"metric": "error_count", "aggregations": ["sum"]},
{"metric": "latency_ms", "aggregations": ["avg", "min", "max"], "percentiles": [50, 95, 99]}
]
}
API_KEY = os.getenv("WANDB_API_KEY")
response = requests.post(url, json=payload, auth=("api", API_KEY))
print(json.dumps(response.json(), indent=2))
```
```typescript twoslash TypeScript lines {6-7,13-20} theme={null}
// @noErrors
const url = "https://trace.wandb.ai/calls/stats";
const payload = {
project_id: "[YOUR-TEAM-NAME/YOUR-PROJECT-NAME]",
start: "2026-03-01T00:00:00Z",
// Spécifiez la taille des buckets, en secondes.
granularity: 86400,
filter: {
trace_roots_only: true,
op_names: ["web_app"],
},
// Spécifiez les métriques et leur fonction d'agrégation
usage_metrics: [
{ metric: "total_tokens", aggregations: ["sum"] },
{ metric: "total_cost", aggregations: ["sum"] },
],
call_metrics: [
{ metric: "call_count", aggregations: ["sum"] },
{ metric: "error_count", aggregations: ["sum"] },
{ metric: "latency_ms", aggregations: ["avg", "min", "max"], percentiles: [50, 95, 99] },
],
};
const API_KEY = process.env.WANDB_API_KEY!;
const response = await fetch(url, {
method: "POST",
headers: {
"Content-Type": "application/json",
Authorization: "Basic " + btoa(`api:${API_KEY}`),
},
body: JSON.stringify(payload),
});
const data = await response.json();
console.log(JSON.stringify(data, null, 2));
```
La requête précise également comment agréger les métriques. Vous pouvez agréger les métriques par `sum`, `count`, `avg`, `min`, `max` et `count`.
Le point de terminaison renvoie un objet JSON. L'exemple de réponse suivant montre des métriques sur deux jours. Chaque jour (bucket) apparaît comme un objet distinct dans les tableaux `usage_buckets` et `call_buckets`. Chaque tableau répartit les métriques différemment :
* `usage_buckets` : regroupe les métriques d'appel de chaque jour par modèle utilisé.
* `call_buckets` : regroupe les métriques d'appel de chaque jour, quel que soit le modèle utilisé.
Définissez le champ granularity (en secondes) dans la requête pour modifier la taille des buckets.
```json lines theme={null}
{
"start": "2026-03-03T00:00:00Z",
"end": "2026-03-04T21:34:39.746539Z",
"granularity": 86400,
"timezone": "UTC",
"usage_buckets": [
{
"timestamp": "2026-03-03T00:00:00",
"model": "gpt-4o-2024-08-06",
"sum_total_tokens": 498.0,
"sum_input_tokens": 219.0,
"sum_output_tokens": 279.0,
"count": 5,
"sum_total_cost": 0.0033374999156876584
},
{
"timestamp": "2026-03-03T00:00:00",
"model": "gpt-5-2025-08-07",
"sum_total_tokens": 0.0,
"sum_input_tokens": 0.0,
"sum_output_tokens": 0.0,
"count": 0,
"sum_total_cost": 0.0
},
{
"timestamp": "2026-03-04T00:00:00",
"model": "gpt-4o-2024-08-06",
"sum_total_tokens": 58.0,
"sum_input_tokens": 27.0,
"sum_output_tokens": 31.0,
"count": 1,
"sum_total_cost": 0.0003774999904635479
},
{
"timestamp": "2026-03-04T00:00:00",
"model": "gpt-5-2025-08-07",
"sum_total_tokens": 427.0,
"sum_input_tokens": 26.0,
"sum_output_tokens": 401.0,
"count": 1,
"sum_total_cost": 0.00404249989787786
}
],
"call_buckets": [
{
"timestamp": "2026-03-03T00:00:00",
"sum_call_count": 6,
"sum_error_count": 1,
"avg_latency_ms": 1505.6666666666667,
"min_latency_ms": 525,
"max_latency_ms": 2524,
"p50_latency_ms": 1534.0,
"p95_latency_ms": 2328.5,
"p99_latency_ms": 2484.9000000000005,
"count": 6
},
{
"timestamp": "2026-03-04T00:00:00",
"sum_call_count": 2,
"sum_error_count": 0,
"avg_latency_ms": 3645.0,
"min_latency_ms": 1739,
"max_latency_ms": 5551,
"p50_latency_ms": 3645.0,
"p95_latency_ms": 5360.4,
"p99_latency_ms": 5512.88,
"count": 2
}
]
}
```
Vous pouvez interroger les métriques sur une période maximale de 31 jours. Pour plus d’informations sur les options disponibles, voir la [référence de l’API de service](https://docs.wandb.ai/weave/reference/service-api/calls/call-stats).