> ## Documentation Index
> Fetch the complete documentation index at: https://docs.apimart.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Sora2 — Création de personnage (Gestion des personnages)

>  - Extrayez des personnages à partir de vidéos pour les utiliser dans la génération de vidéos ultérieures
- Mode de traitement asynchrone, retourne un identifiant de tâche pour les requêtes ultérieures
- La vidéo doit contenir du son et des personnages 

<RequestExample>
  ```bash cURL theme={null}
  curl --request POST \
    --url https://api.apimart.ai/v1/videos/generations \
    --header 'Authorization: Bearer <token>' \
    --header 'Content-Type: application/json' \
    --data '{
      "model": "sora-2-vip",
      "url": "https://cdn.apimart.ai/modelDefaultUrl/Sora-2-vip.mp4",
      "timestamps": "1,3"
    }'
  ```

  ```python Python theme={null}
  import requests

  url = "https://api.apimart.ai/v1/videos/generations"

  payload = {
      "model": "sora-2-vip",
      "url": "https://cdn.apimart.ai/modelDefaultUrl/Sora-2-vip.mp4",
      "timestamps": "1,3"
  }

  headers = {
      "Authorization": "Bearer <token>",
      "Content-Type": "application/json"
  }

  response = requests.post(url, json=payload, headers=headers)

  print(response.json())
  ```

  ```javascript JavaScript theme={null}
  const url = "https://api.apimart.ai/v1/videos/generations";

  const payload = {
    model: "sora-2-vip",
    url: "https://cdn.apimart.ai/modelDefaultUrl/Sora-2-vip.mp4",
    timestamps: "1,3"
  };

  const headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
  };

  fetch(url, {
    method: "POST",
    headers: headers,
    body: JSON.stringify(payload)
  })
    .then(response => response.json())
    .then(data => console.log(data))
    .catch(error => console.error('Error:', error));
  ```

  ```go Go theme={null}
  package main

  import (
      "bytes"
      "encoding/json"
      "fmt"
      "io/ioutil"
      "net/http"
  )

  func main() {
      url := "https://api.apimart.ai/v1/videos/generations"

      payload := map[string]interface{}{
          "model":      "sora-2-vip",
          "url":        "https://cdn.apimart.ai/modelDefaultUrl/Sora-2-vip.mp4",
          "timestamps": "1,3",
      }

      jsonData, _ := json.Marshal(payload)

      req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
      req.Header.Set("Authorization", "Bearer <token>")
      req.Header.Set("Content-Type", "application/json")

      client := &http.Client{}
      resp, err := client.Do(req)
      if err != nil {
          panic(err)
      }
      defer resp.Body.Close()

      body, _ := ioutil.ReadAll(resp.Body)
      fmt.Println(string(body))
  }
  ```

  ```java Java theme={null}
  import java.net.http.HttpClient;
  import java.net.http.HttpRequest;
  import java.net.http.HttpResponse;
  import java.net.URI;

  public class Main {
      public static void main(String[] args) throws Exception {
          String url = "https://api.apimart.ai/v1/videos/generations";

          String payload = """
          {
            "model": "sora-2-vip",
            "url": "https://cdn.apimart.ai/modelDefaultUrl/Sora-2-vip.mp4",
            "timestamps": "1,3"
          }
          """;

          HttpClient client = HttpClient.newHttpClient();
          HttpRequest request = HttpRequest.newBuilder()
              .uri(URI.create(url))
              .header("Authorization", "Bearer <token>")
              .header("Content-Type", "application/json")
              .POST(HttpRequest.BodyPublishers.ofString(payload))
              .build();

          HttpResponse<String> response = client.send(request,
              HttpResponse.BodyHandlers.ofString());

          System.out.println(response.body());
      }
  }
  ```

  ```php PHP theme={null}
  <?php

  $url = "https://api.apimart.ai/v1/videos/generations";

  $payload = [
      "model" => "sora-2-vip",
      "url" => "https://cdn.apimart.ai/modelDefaultUrl/Sora-2-vip.mp4",
      "timestamps" => "1,3"
  ];

  $ch = curl_init($url);
  curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
  curl_setopt($ch, CURLOPT_POST, true);
  curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
  curl_setopt($ch, CURLOPT_HTTPHEADER, [
      "Authorization: Bearer <token>",
      "Content-Type: application/json"
  ]);

  $response = curl_exec($ch);
  curl_close($ch);

  echo $response;
  ?>
  ```

  ```ruby Ruby theme={null}
  require 'net/http'
  require 'json'
  require 'uri'

  url = URI("https://api.apimart.ai/v1/videos/generations")

  payload = {
    model: "sora-2-vip",
    url: "https://cdn.apimart.ai/modelDefaultUrl/Sora-2-vip.mp4",
    timestamps: "1,3"
  }

  http = Net::HTTP.new(url.host, url.port)
  http.use_ssl = true

  request = Net::HTTP::Post.new(url)
  request["Authorization"] = "Bearer <token>"
  request["Content-Type"] = "application/json"
  request.body = payload.to_json

  response = http.request(request)
  puts response.body
  ```

  ```swift Swift theme={null}
  import Foundation

  let url = URL(string: "https://api.apimart.ai/v1/videos/generations")!

  let payload: [String: Any] = [
      "model": "sora-2-vip",
      "url": "https://cdn.apimart.ai/modelDefaultUrl/Sora-2-vip.mp4",
      "timestamps": "1,3"
  ]

  var request = URLRequest(url: url)
  request.httpMethod = "POST"
  request.setValue("Bearer <token>", forHTTPHeaderField: "Authorization")
  request.setValue("application/json", forHTTPHeaderField: "Content-Type")
  request.httpBody = try? JSONSerialization.data(withJSONObject: payload)

  let task = URLSession.shared.dataTask(with: request) { data, response, error in
      if let error = error {
          print("Error: \(error)")
          return
      }
      
      if let data = data, let responseString = String(data: data, encoding: .utf8) {
          print(responseString)
      }
  }

  task.resume()
  ```

  ```csharp C# theme={null}
  using System;
  using System.Net.Http;
  using System.Text;
  using System.Threading.Tasks;

  class Program
  {
      static async Task Main(string[] args)
      {
          var url = "https://api.apimart.ai/v1/videos/generations";

          var payload = @"{
              ""model"": ""sora-2-vip"",
              ""url"": ""https://cdn.apimart.ai/modelDefaultUrl/Sora-2-vip.mp4"",
              ""timestamps"": ""1,3""
          }";

          using var client = new HttpClient();
          client.DefaultRequestHeaders.Add("Authorization", "Bearer <token>");

          var content = new StringContent(payload, Encoding.UTF8, "application/json");
          var response = await client.PostAsync(url, content);
          var result = await response.Content.ReadAsStringAsync();

          Console.WriteLine(result);
      }
  }
  ```

  ```c C theme={null}
  #include <stdio.h>
  #include <curl/curl.h>

  int main(void) {
      CURL *curl;
      CURLcode res;

      curl_global_init(CURL_GLOBAL_DEFAULT);
      curl = curl_easy_init();

      if(curl) {
          const char *url = "https://api.apimart.ai/v1/videos/generations";
          const char *payload = "{"
              "\"model\":\"sora-2-vip\","
              "\"url\":\"https://cdn.apimart.ai/modelDefaultUrl/Sora-2-vip.mp4\","
              "\"timestamps\":\"1,3\""
          "}";

          struct curl_slist *headers = NULL;
          headers = curl_slist_append(headers, "Authorization: Bearer <token>");
          headers = curl_slist_append(headers, "Content-Type: application/json");

          curl_easy_setopt(curl, CURLOPT_URL, url);
          curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
          curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);

          res = curl_easy_perform(curl);

          if(res != CURLE_OK) {
              fprintf(stderr, "curl_easy_perform() failed: %s\n",
                      curl_easy_strerror(res));
          }

          curl_slist_free_all(headers);
          curl_easy_cleanup(curl);
      }

      curl_global_cleanup();
      return 0;
  }
  ```

  ```objectivec Objective-C theme={null}
  #import <Foundation/Foundation.h>

  int main(int argc, const char * argv[]) {
      @autoreleasepool {
          NSURL *url = [NSURL URLWithString:@"https://api.apimart.ai/v1/videos/generations"];
          
          NSDictionary *payload = @{
              @"model": @"sora-2-vip",
              @"url": @"https://cdn.apimart.ai/modelDefaultUrl/Sora-2-vip.mp4",
              @"timestamps": @"1,3"
          };
          
          NSError *error;
          NSData *jsonData = [NSJSONSerialization dataWithJSONObject:payload
                                                            options:0
                                                              error:&error];
          
          NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
          [request setHTTPMethod:@"POST"];
          [request setValue:@"Bearer <token>" forHTTPHeaderField:@"Authorization"];
          [request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
          [request setHTTPBody:jsonData];
          
          NSURLSessionDataTask *task = [[NSURLSession sharedSession] 
              dataTaskWithRequest:request
              completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                  if (error) {
                      NSLog(@"Error: %@", error);
                      return;
                  }
                  NSString *result = [[NSString alloc] initWithData:data 
                                                          encoding:NSUTF8StringEncoding];
                  NSLog(@"%@", result);
              }];
          
          [task resume];
          [[NSRunLoop mainRunLoop] run];
      }
      return 0;
  }
  ```

  ```ocaml OCaml theme={null}
  (* Requires cohttp and yojson libraries *)
  open Lwt
  open Cohttp
  open Cohttp_lwt_unix

  let url = "https://api.apimart.ai/v1/videos/generations"

  let payload = {|{
    "model": "sora-2-vip",
    "url": "https://cdn.apimart.ai/modelDefaultUrl/Sora-2-vip.mp4",
    "timestamps": "1,3"
  }|}

  let () =
    let headers = Header.init ()
      |> fun h -> Header.add h "Authorization" "Bearer <token>"
      |> fun h -> Header.add h "Content-Type" "application/json"
    in
    let body = Cohttp_lwt.Body.of_string payload in
    
    let response = Client.post ~headers ~body (Uri.of_string url) >>= fun (resp, body) ->
      body |> Cohttp_lwt.Body.to_string >|= fun body_str ->
      print_endline body_str
    in
    Lwt_main.run response
  ```

  ```dart Dart theme={null}
  import 'dart:convert';
  import 'package:http/http.dart' as http;

  void main() async {
    final url = Uri.parse('https://api.apimart.ai/v1/videos/generations');
    
    final payload = {
      'model': 'sora-2-vip',
      'url': 'https://cdn.apimart.ai/modelDefaultUrl/Sora-2-vip.mp4',
      'timestamps': '1,3'
    };
    
    final response = await http.post(
      url,
      headers: {
        'Authorization': 'Bearer <token>',
        'Content-Type': 'application/json',
      },
      body: jsonEncode(payload),
    );
    
    print(response.body);
  }
  ```

  ```r R theme={null}
  library(httr)
  library(jsonlite)

  url <- "https://api.apimart.ai/v1/videos/generations"

  payload <- list(
    model = "sora-2-vip",
    url = "https://cdn.apimart.ai/modelDefaultUrl/Sora-2-vip.mp4",
    timestamps = "1,3"
  )

  response <- POST(
    url,
    add_headers(
      Authorization = "Bearer <token>",
      `Content-Type` = "application/json"
    ),
    body = toJSON(payload, auto_unbox = TRUE),
    encode = "raw"
  )

  cat(content(response, "text"))
  ```
</RequestExample>

<ResponseExample>
  ```json 200 theme={null}
  {
    "code": 200,
    "data": [
      {
        "status": "submitted",
        "task_id": "task_01KBYT59JDHB4A3KDDR9N9JVWP"
      }
    ]
  }
  ```

  ```json 400 theme={null}
  {
    "error": {
      "code": 400,
      "message": "Invalid request parameters",
      "type": "invalid_request_error"
    }
  }
  ```

  ```json 401 theme={null}
  {
    "error": {
      "code": 401,
      "message": "Invalid authentication credentials",
      "type": "authentication_error"
    }
  }
  ```

  ```json 402 theme={null}
  {
    "error": {
      "code": 402,
      "message": "Insufficient balance. Please top up your account",
      "type": "payment_required"
    }
  }
  ```

  ```json 403 theme={null}
  {
    "error": {
      "code": 403,
      "message": "Access forbidden. You don't have permission to access this resource",
      "type": "permission_error"
    }
  }
  ```

  ```json 429 theme={null}
  {
    "error": {
      "code": 429,
      "message": "Rate limit exceeded. Please try again later",
      "type": "rate_limit_error"
    }
  }
  ```

  ```json 500 theme={null}
  {
    "error": {
      "code": 500,
      "message": "Internal server error. Please try again later",
      "type": "server_error"
    }
  }
  ```

  ```json 502 theme={null}
  {
    "error": {
      "code": 502,
      "message": "Bad gateway. The server is temporarily unavailable",
      "type": "bad_gateway"
    }
  }
  ```
</ResponseExample>

## Autorisations

<ParamField header="Authorization" type="string" required>
  Tous les points de terminaison de l'API nécessitent une authentification Bearer Token

  Obtenez votre clé API :

  Visitez la [page de gestion des clés API](https://apimart.ai/keys) pour obtenir votre clé API

  Ajoutez-la à l'en-tête de la requête :

  ```
  Authorization: Bearer YOUR_API_KEY
  ```
</ParamField>

## Body

<ParamField body="model" type="string" required>
  Nom du modèle de génération de vidéos
</ParamField>

<ParamField body="timestamps" type="string" required>
  Plage d'horodatage d'apparition du personnage

  En secondes, format : `"seconde_de_début,seconde_de_fin"`

  **⚠️ Limitations :**

  * Différence minimale de plage de temps : 1 seconde
  * Différence maximale de plage de temps : 3 secondes

  Exemple : `"1,3"` signifie que le personnage apparaît de la seconde 1 à la seconde 3 dans la vidéo
</ParamField>

<ParamField body="url" type="string">
  URL de la vidéo contenant le personnage à créer

  **⚠️ Exigences :**

  * La vidéo doit contenir du son
  * La vidéo doit contenir un personnage

  **💡 Remarque :**

  * `url` ou `from_task` doit être fourni (au choix)

  Exemple : `"https://cdn.apimart.ai/modelDefaultUrl/Sora-2-vip.mp4"`
</ParamField>

<ParamField body="from_task" type="string">
  Identifiant d'une tâche de vidéo générée précédemment

  Créez un personnage à partir d'une tâche de vidéo déjà générée

  **💡 Remarque :**

  * `url` ou `from_task` doit être fourni (au choix)
  * Utilisez ce paramètre pour extraire des personnages directement à partir de tâches de vidéo générées précédemment

  Exemple : `"task_01KBYT59JDHB4A3KDDR9N9JVWP"`
</ParamField>

## Response

<ResponseField name="code" type="integer">
  Code de statut de la réponse, 200 en cas de succès
</ResponseField>

<ResponseField name="data" type="array">
  Tableau de données de la réponse

  <Expandable title="Éléments du tableau">
    <ResponseField name="status" type="string">
      Statut de la tâche, `submitted` lors de la soumission initiale
    </ResponseField>

    <ResponseField name="task_id" type="string">
      Identifiant unique de la tâche pour interroger le statut et les résultats de la tâche

      Une fois terminée, vous pouvez utiliser cet identifiant de tâche de personnage pour référencer le personnage via le paramètre `character_url` dans la génération de vidéos
    </ResponseField>
  </Expandable>
</ResponseField>