Tutorial API 2Slides - Kompletny przewodnik po generowaniu prezentacji AI

Witamy w kompleksowym przewodniku po API 2Slides! Ten tutorial przeprowadzi Cię przez wszystko, co musisz wiedzieć, aby zintegrować generowanie prezentacji w oparciu o AI ze swoimi aplikacjami.

Przegląd

API 2Slides umożliwia programowe generowanie profesjonalnych prezentacji przy użyciu AI. Dzięki obsłudze wielu typów prezentacji, w tym osi czasu, roadmap, map myśli i innych, możesz tworzyć oszałamiające slajdy z prostego tekstu.

Kluczowe funkcje

• Generowanie w oparciu o AI: Automatyczne tworzenie profesjonalnych prezentacji z tekstu
• Wiele typów szablonów: Obsługa osi czasu, roadmap, map myśli, pitch decków, infografik i innych
• Obsługa wielu języków: Generowanie treści w wielu językach
• Bogata biblioteka szablonów: Dostęp do setek profesjonalnie zaprojektowanych szablonów
• Własne szablony: Możliwość przesyłania i używania własnych szablonów slajdów
• Wyszukiwanie szablonów: Wyszukiwanie szablonów według nazwy, słów kluczowych i tagów
• Opcje pobierania: Pobieranie prezentacji w formacie PowerPoint (.pptx)
• Śledzenie statusu w czasie rzeczywistym: Monitorowanie postępu generowania za pomocą endpointów statusu zadań

Polecane typy prezentacji

Wszystkie szablony prezentacji są dostępne tutaj: Szablony 2Slides. W szczególności istnieją polecane typy prezentacji, które świetnie sprawdzają się w określonych celach i scenariuszach.

1. Slajdy z osią czasu - Idealne do harmonogramów projektów i wydarzeń historycznych
2. Slajdy Roadmap - Doskonałe do roadmap produktowych i planowania projektów
3. Slajdy z mapą myśli - Świetne do mapowania koncepcji i struktury wiedzy

Rozpoczęcie pracy

Bazowy adres URL

Wszystkie żądania API powinny być wysyłane na:

https://2slides.com

Wymagania wstępne

1. Konfiguracja konta: Utwórz konto na 2slides.com
2. Klucz API: Wygeneruj klucz API ze swojej strony zarządzania API
3. Kredyty: Upewnij się, że masz wystarczającą ilość kredytów do generowania slajdów (10 kredytów za stronę slajdu)

Szybki start

1. Pobierz swój klucz API ze strony zarządzania API
2. Wyszukaj motyw używając endpointu wyszukiwania motywów lub przeglądaj szablony, aby uzyskać identyfikator motywu slajdu
3. Wygeneruj slajdy ze swoją treścią i wybranym identyfikatorem motywu. Obsługiwane jest zarówno wywołanie synchroniczne ze zwracanymi wynikowymi slajdami, jak i wywołanie asynchroniczne ze zwracanym identyfikatorem zadania. W przypadku użycia wywołania synchronicznego kolejne kroki 4 i 5 nie są potrzebne
4. Sprawdź status zadania do momentu zakończenia. Zostanie udostępniony URL do pobrania wygenerowanych slajdów
5. Pobierz swoją prezentację używając dostarczonego linku do pobrania

Uwierzytelnianie

Wszystkie endpointy API wymagają uwierzytelnienia przy użyciu klucza API. Możesz zarządzać swoimi kluczami API poprzez interfejs zarządzania API.

Format klucza API

Klucze API mają następujący format:

sk-2slides-{64-znakowy-ciąg-szesnastkowy}

Metody uwierzytelniania

Nagłówek Authorization

Authorization: Bearer sk-2slides-twoj-klucz-api-tutaj

Zarządzanie kluczami API

• Maksymalna liczba kluczy: Każdy użytkownik może utworzyć do 10 kluczy API
• Nazewnictwo kluczy: Nadawaj swoim kluczom opisowe nazwy dla łatwej identyfikacji
• Bezpieczeństwo: Przechowuj swoje klucze API bezpiecznie i nigdy nie udostępniaj ich publicznie
• Rotacja: Regularnie rotuj swoje klucze API dla zwiększenia bezpieczeństwa

⚠️ Ważne powiadomienie o bezpieczeństwie: Platforma 2slides NIE przechowuje Twoich kluczy API w postaci jawnego tekstu ze względów bezpieczeństwa. Po wygenerowaniu musisz natychmiast skopiować i bezpiecznie zapisać swój klucz API. Jeśli zgubisz swój klucz API, będziesz musiał wygenerować nowy, ponieważ oryginału nie można odzyskać.

Endpointy API

1. Generowanie Slajdów (Fast PPT)

Generowanie slajdów (Fast PPT) z tekstu wejściowego przy użyciu określonego motywu.

Endpoint:

Nagłówki:

Authorization: Bearer sk-2slides-your-api-key-here
Content-Type: application/json

Treść Żądania:

{
  "userInput": "Treść Twojej prezentacji tutaj...",
  "themeId": "theme-uuid-here",
  "responseLanguage": "Auto"
}

Parametry:

• userInput
  (wymagane): Treść, dla której chcesz wygenerować slajdy
• themeId
  (wymagane): ID motywu do użycia przy generowaniu slajdów. Może to być:
  • Motywy publiczne z galerii szablonów
  • Twoje własne przesłane niestandardowe motywy (dostępne przez Twoje konto)
• responseLanguage
  (opcjonalne): Język generowanych slajdów. Użyj "Auto" dla automatycznego wykrywania
• mode
  (opcjonalne): Wywołanie synchroniczne (sync) lub asynchroniczne (async), domyślnie "sync"

Dostępne Języki:

• Auto
  - Automatyczne wykrywanie języka z danych wejściowych (domyślne)
• English
  - Angielski
• Simplified Chinese
  - 简体中文
• Traditional Chinese
  - 繁體中文
• Spanish
  - Español
• Arabic
  - العربية
• Portuguese
  - Português
• Indonesian
  - Bahasa Indonesia
• Japanese
  - 日本語
• Russian
  - Русский
• Hindi
  - हिंदी
• French
  - Français
• German
  - Deutsch
• Vietnamese
  - Tiếng Việt
• Turkish
  - Türkçe
• Polish
  - Polski
• Italian
  - Italiano
• Korean
  - 한국어

Odpowiedź w trybie async:

{
  "success": true,
  "data": {
    "jobId": "job-uuid-here",
    "status": "processing",
    "message": "Rozpoczęto generowanie slajdów. Użyj jobId, aby sprawdzić status.",
    "credits": {
      "current": 150,
      "required": 30
    }
  }
}

Odpowiedź w trybie sync:

{
  "success": true,
  "data": {
    "jobId": "1pFqIww3JjquQ1T3Ysmw1",
    "status": "success",
    "message": "Slajdy wygenerowane pomyślnie",
    "downloadUrl": "https://presigned-url-here",
    "createdAt": 1760347015388,
    "updatedAt": 1760347048261,
    "duration": 32694,
    "slidePageCount": 9
  }
}

2. Sprawdzanie Statusu Zadania (Fast PPT)

Sprawdzenie statusu zadania generowania slajdów (Fast PPT) i uzyskanie wyników po zakończeniu.

Endpoint:

Nagłówki:

Authorization: Bearer sk-2slides-your-api-key-here

Przykłady Odpowiedzi:

Przetwarzanie:

{
  "success": true,
  "data": {
    "jobId": "job-uuid-here",
    "status": "processing",
    "message": "Generowanie slajdów w toku",
    "createdAt": 1703123456789,
    "updatedAt": 1703123460000
  }
}

Sukces:

{
  "success": true,
  "data": {
    "jobId": "job-uuid-here",
    "status": "success",
    "message": "Slajdy wygenerowane pomyślnie",
    "downloadUrl": "https://presigned-url-here",
    "createdAt": 1703123456789,
    "updatedAt": 1703123500000,
    "duration": 33211,
    "slidePageCount": 3
  }
}

Niepowodzenie:

{
  "success": true,
  "data": {
    "jobId": "job-uuid-here",
    "status": "failed",
    "message": "Generowanie slajdów nie powiodło się",
    "errorMessage": "Niewystarczające kredyty do generowania",
    "createdAt": 1703123456789,
    "updatedAt": 1703123460000
  }
}

3. Tworzenie Slajdów Jak Ten (Nano Banana Pro)

Generowanie slajdów (Nano Banana Pro) na podstawie obrazu referencyjnego. Ten endpoint używa trybu synchronicznego i automatycznie generuje PDF, gdy wszystkie slajdy są ukończone.

Endpoint:

Nagłówki:

Authorization: Bearer sk-2slides-your-api-key-here
Content-Type: application/json

Treść Żądania:

{
  "userInput": "Treść Twojej prezentacji tutaj...",
  "referenceImageUrl": "https://example.com/reference-image.jpg",
  "responseLanguage": "Auto",
  "aspectRatio": "16:9",
  "resolution": "2K",
  "page": 1
}

Parametry:

• userInput
  (wymagane): Treść, dla której chcesz wygenerować slajdy
• referenceImageUrl
  (wymagane): URL obrazu referencyjnego, aby naśladować styl projektu. Obsługuje:
  • Adresy URL HTTP/HTTPS
  • Adresy URL danych Base64 (data:image/...)
• responseLanguage
  (opcjonalne): Język generowanych slajdów. Użyj "Auto" dla automatycznego wykrywania (domyślnie: "Auto")
• aspectRatio
  (opcjonalne): Proporcje obrazu dla slajdów. Format: "szerokość:wysokość" (domyślnie: "16:9")
• resolution
  (opcjonalne): Rozdzielczość obrazów slajdów. Opcje: "1K", "2K", "4K" (domyślnie: "2K")
• page
  (opcjonalne): Liczba slajdów do wygenerowania. Użyj 0 dla automatycznego wykrywania. Określ liczbę (>=1, maks: 100), aby wymusić taką liczbę slajdów. Domyślnie: 1.
• contentDetail
  (opcjonalne): Poziom szczegółowości treści dla slajdów. Opcje: "concise" (zwięzły, skoncentrowany na słowach kluczowych) lub "standard" (kompleksowy, szczegółowy). Domyślnie: "concise".

Odpowiedź:

{
  "success": true,
  "data": {
    "jobId": "job-uuid-here",
    "status": "success",
    "message": "Pomyślnie wygenerowano 5 slajdów",
    "downloadUrl": "https://presigned-url-to-pdf.pdf",
    "jobUrl": "https://2slides.com/workspace?jobId=job-uuid-here",
    "createdAt": 1703123456789,
    "updatedAt": 1703123500000,
    "slidePageCount": 5,
    "successCount": 5,
    "failedCount": 0
  }
}

Wartości Statusu:

• success
  : Wszystkie slajdy wygenerowane pomyślnie, PDF jest dostępny
• partial
  : Niektóre slajdy nie zostały wygenerowane
• failed
  : Wszystkie slajdy nie zostały wygenerowane

Uwaga: Ten endpoint działa w trybie synchronicznym i będzie czekał na wygenerowanie wszystkich slajdów przed zwróceniem odpowiedzi.

4. Wyszukiwanie Motywów (Fast PPT)

Wyszukiwanie dostępnych motywów slajdów (Fast PPT) według słowa kluczowego. Obejmuje to zarówno motywy publiczne, jak i Twoje własne przesłane niestandardowe motywy.

Endpoint:

Nagłówki:

Authorization: Bearer sk-2slides-your-api-key-here

Parametry Zapytania:

• query
  (wymagane): Słowo kluczowe do wyszukiwania w nazwie motywu, opisie i tagach
• limit
  (opcjonalne): Maksymalna liczba wyników (1-100, domyślnie 20)

Przykładowe Żądanie:

GET /api/v1/themes/search?query=timeline&limit=10

Odpowiedź:

{
  "success": true,
  "data": {
    "total": 25,
    "themes": [
      {
        "id": "theme-uuid-1",
        "name": "Modern Timeline",
        "description": "Czysty i nowoczesny szablon osi czasu do prezentacji projektów",
        "tags": "timeline, modern, project, clean",
        "themeURL": "https://2slides.com/templates/st-1759917935785-nx0z6ae54"
      },
      {
        "id": "theme-uuid-2",
        "name": "Business Roadmap",
        "description": "Profesjonalny szablon mapy drogowej do planowania biznesowego",
        "tags": "roadmap, business, planning, professional",
        "themeURL": "https://2slides.com/templates/st-1755509077270-sftfm616s"
      }
    ]
  }
}

Limity zapytań

API implementuje limity zapytań, aby zapewnić uczciwe użytkowanie i stabilność systemu. Różne endpointy mają różne limity:

Nagłówki limitów zapytań

Gdy limity zapytań zostaną przekroczone, API zwraca odpowiedź

z następującymi nagłówkami:

HTTP/1.1 429 Too Many Requests
X-RateLimit-Limit: 6
X-RateLimit-Remaining: 0
X-RateLimit-Reset: 1703123600
Retry-After: 45

Obsługa limitów zapytań

Musisz ostrożnie obsługiwać limity wywołań API, oto przykład w Javascript.

async function makeApiRequest(url, options) {
  try {
    const response = await fetch(url, options);
    
    if (response.status === 429) {
      const retryAfter = response.headers.get('Retry-After');
      console.log(`Limit zapytań przekroczony. Ponów za ${retryAfter} sekund`);
      await new Promise(resolve => setTimeout(resolve, retryAfter * 1000));
      return makeApiRequest(url, options); // Ponów próbę
    }
    
    return response;
  } catch (error) {
    console.error('Zapytanie API nie powiodło się:', error);
    throw error;
  }
}

System kredytów

2Slides wykorzystuje system kredytowy do generowania slajdów. Każda strona slajdu kosztuje 10 kredytów.

Zasady kredytów

• Nowi użytkownicy: Otrzymują 880 darmowych kredytów po rejestracji
• Koszt: 10 kredytów za stronę slajdu (Fast PPT), 100 kredytów za stronę 1K/2K Nano Banana Pro, 200 kredytów za stronę 4K Nano Banana Pro
• Minimum: Użytkownicy potrzebują co najmniej 10 kredytów, aby rozpocząć generowanie
• Potrącenie: Kredyty są potrącane tylko po pomyślnym wygenerowaniu
• Zwroty: Kredyty są zwracane, jeśli generowanie nie powiedzie się

Sprawdzanie kredytów

Możesz sprawdzić saldo kredytów poprzez panel konta lub sprawdzając informacje o kredytach w odpowiedziach API.

Zakup kredytów

Dodatkowe kredyty można kupić poprzez stronę cennika przy użyciu różnych metod płatności.

Przykłady

Kompletny przykład workflow

Oto kompletny przykład generowania slajdów za pomocą API 2slides w Javascript i Python:

const API_KEY = 'sk-2slides-your-api-key-here';
const BASE_URL = 'https://2slides.com';

async function generateSlides() {
  try {
    // Krok 1: Wyszukaj motyw
    const themeResponse = await fetch(
      `${BASE_URL}/api/v1/themes/search?query=timeline&limit=5`,
      {
        headers: {
          'Authorization': `Bearer ${API_KEY}`,
          'Content-Type': 'application/json'
        }
      }
    );
    
    const themeData = await themeResponse.json();
    const themeId = themeData.data.themes[0].id;
    
    // Krok 2: Wygeneruj slajdy
    const generateResponse = await fetch(
      `${BASE_URL}/api/v1/slides/generate`,
      {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${API_KEY}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          userInput: "Utwórz oś czasu dla rozwoju naszego produktu: Q1 - Badania i planowanie, Q2 - Rozwój MVP, Q3 - Testy beta, Q4 - Publiczne wdrożenie",
          themeId: themeId,
          responseLanguage: "Polish",
          mode: "async"
        })
      }
    );
    
    const generateData = await generateResponse.json();
    const jobId = generateData.data.jobId;
    
    // Krok 3: Sprawdzaj status wykonania
    let jobStatus;
    do {
      await new Promise(resolve => setTimeout(resolve, 2000)); // Poczekaj 2 sekundy
      
      const statusResponse = await fetch(
        `${BASE_URL}/api/v1/jobs/${jobId}`,
        {
          headers: {
            'Authorization': `Bearer ${API_KEY}`
          }
        }
      );
      
      jobStatus = await statusResponse.json();
      console.log(`Status: ${jobStatus.data.status}`);
      
    } while (jobStatus.data.status === 'processing' || jobStatus.data.status === 'pending');
    
    // Krok 4: Obsłuż wynik
    if (jobStatus.data.status === 'success') {
      console.log('Slajdy wygenerowane pomyślnie!');
      console.log('URL pobierania:', jobStatus.data.downloadUrl);
      console.log('Wygenerowane strony:', jobStatus.data.slidePageCount);
      
      // Pobierz plik
      const downloadResponse = await fetch(jobStatus.data.downloadUrl);
      const blob = await downloadResponse.blob();
      
      // Utwórz link do pobrania
      const url = window.URL.createObjectURL(blob);
      const a = document.createElement('a');
      a.href = url;
      a.download = 'presentation.pptx';
      a.click();
      window.URL.revokeObjectURL(url);
      
    } else {
      console.error('Generowanie nie powiodło się:', jobStatus.data.errorMessage);
    }
    
  } catch (error) {
    console.error('Błąd:', error);
  }
}

// Uruchom przykład
generateSlides();

Przykład Python

import requests
import time
import json

API_KEY = 'sk-2slides-your-api-key-here'
BASE_URL = 'https://2slides.com'

def generate_slides():
    headers = {
        'Authorization': f'Bearer {API_KEY}',
        'Content-Type': 'application/json'
    }
    
    try:
        # Krok 1: Wyszukaj motyw
        theme_response = requests.get(
            f'{BASE_URL}/api/v1/themes/search',
            params={'query': 'roadmap', 'limit': 5},
            headers=headers
        )
        theme_data = theme_response.json()
        theme_id = theme_data['data']['themes'][0]['id']
        
        # Krok 2: Wygeneruj slajdy
        generate_payload = {
            'userInput': 'Stwórz mapę drogową produktu dla naszej aplikacji mobilnej: Faza 1 - Podstawowe funkcje, Faza 2 - Zaawansowane funkcje, Faza 3 - Integracja AI',
            'themeId': theme_id,
            'responseLanguage': 'Polish',
            'mode': 'async'
        }
        
        generate_response = requests.post(
            f'{BASE_URL}/api/v1/slides/generate',
            headers=headers,
            json=generate_payload
        )
        generate_data = generate_response.json()
        job_id = generate_data['data']['jobId']
        
        # Krok 3: Sprawdzaj status wykonania
        while True:
            time.sleep(2)  # Poczekaj 2 sekundy
            
            status_response = requests.get(
                f'{BASE_URL}/api/v1/jobs/{job_id}',
                headers=headers
            )
            status_data = status_response.json()
            status = status_data['data']['status']
            
            print(f'Status: {status}')
            
            if status in ['success', 'failed']:
                break
        
        # Krok 4: Obsłuż wynik
        if status == 'success':
            print('Slajdy wygenerowane pomyślnie!')
            print(f'URL pobierania: {status_data["data"]["downloadUrl"]}')
            print(f'Wygenerowane strony: {status_data["data"]["slidePageCount"]}')
            
            # Pobierz plik
            download_response = requests.get(status_data['data']['downloadUrl'])
            with open('presentation.pptx', 'wb') as f:
                f.write(download_response.content)
            print('Plik pobrany jako presentation.pptx')
            
        else:
            print(f'Generowanie nie powiodło się: {status_data["data"]["errorMessage"]}')
            
    except Exception as error:
        print(f'Błąd: {error}')

# Uruchom przykład
generate_slides()

Przykłady cURL

Wyszukaj motywy:

curl -X GET "https://2slides.com/api/v1/themes/search?query=timeline&limit=5" \
  -H "Authorization: Bearer sk-2slides-your-api-key-here" \
  -H "Content-Type: application/json"

Wygeneruj slajdy:

curl -X POST "https://2slides.com/api/v1/slides/generate" \
  -H "Authorization: Bearer sk-2slides-your-api-key-here" \
  -H "Content-Type: application/json" \
  -d '{
    "userInput": "Utwórz oś czasu dla kamieni milowych naszego projektu",
    "themeId": "theme-uuid-here",
    "responseLanguage": "Polish",
    "mode": "async"
  }'

Sprawdź status zadania:

curl -X GET "https://2slides.com/api/v1/jobs/job-uuid-here" \
  -H "Authorization: Bearer sk-2slides-your-api-key-here"

Obsługa błędów

API używa standardowych kodów statusu HTTP i zwraca szczegółowe informacje o błędach w formacie JSON.

Typowe odpowiedzi błędów

400 Bad Request:

{
  "success": false,
  "error": "userInput is required and must be a non-empty string"
}

401 Unauthorized:

{
  "success": false,
  "error": "Authentication required"
}

403 Forbidden:

{
  "success": false,
  "error": "Access denied"
}

404 Not Found:

{
  "success": false,
  "error": "Theme not found"
}

429 Too Many Requests:

{
  "success": false,
  "error": "Rate limit exceeded"
}

500 Internal Server Error:

{
  "success": false,
  "error": "Internal server error"
}

Dobre praktyki obsługi błędów

async function handleApiRequest(url, options) {
  try {
    const response = await fetch(url, options);
    const data = await response.json();
    
    if (!response.ok) {
      switch (response.status) {
        case 400:
          throw new Error(`Nieprawidłowe żądanie: ${data.error}`);
        case 401:
          throw new Error('Uwierzytelnianie nie powiodło się. Sprawdź swój klucz API.');
        case 403:
          throw new Error('Dostęp zabroniony. Możesz nie mieć uprawnień do tego zasobu.');
        case 404:
          throw new Error('Zasób nie został znaleziony.');
        case 429:
          throw new Error('Przekroczono limit zapytań. Spróbuj ponownie później.');
        case 500:
          throw new Error('Błąd serwera. Spróbuj ponownie później.');
        default:
          throw new Error(`Błąd API: ${data.error || 'Nieznany błąd'}`);
      }
    }
    
    return data;
  } catch (error) {
    if (error.name === 'TypeError' && error.message.includes('fetch')) {
      throw new Error('Błąd sieci. Sprawdź swoje połączenie internetowe.');
    }
    throw error;
  }
}

Najlepsze Praktyki

1. Bezpieczeństwo Klucza API

• Nigdy nie ujawniaj kluczy API w kodzie po stronie klienta ani w publicznych repozytoriach
• Używaj zmiennych środowiskowych do bezpiecznego przechowywania kluczy API
• Regularnie rotuj klucze dla zwiększonego bezpieczeństwa
• Monitoruj użycie kluczy za pomocą panelu zarządzania API
• Przechowuj klucze bezpiecznie: Pamiętaj, że 2slides nie przechowuje Twoich kluczy API, więc musisz sam zadbać o ich bezpieczeństwo
• Twórz kopie zapasowe kluczy: Przechowuj klucze API w bezpiecznym menedżerze haseł lub szyfrowanej pamięci

2. Efektywne Wykorzystanie API

• Cachuj wyniki wyszukiwania motywów, aby uniknąć powtarzających się żądań
• Implementuj odpowiednie interwały odpytywania dla sprawdzania statusu zadań (2-5 sekund)
• Obsługuj limity żądań z wdziękiem z wykorzystaniem wykładniczego wycofywania
• Grupuj operacje gdy to możliwe, aby zmniejszyć liczbę wywołań API

3. Obsługa Błędów

• Zawsze sprawdzaj kody statusu odpowiedzi
• Implementuj logikę ponownych prób dla przejściowych awarii
• Loguj błędy odpowiednio dla celów debugowania
• Dostarczaj przyjazne dla użytkownika komunikaty błędów

4. Optymalizacja Wydajności

• Używaj odpowiednich interwałów odpytywania, aby uniknąć niepotrzebnych żądań
• Implementuj limity czasowe żądań, aby zapobiec zawieszaniu się żądań
• Cachuj często używane dane, takie jak informacje o motywach
• Monitoruj wykorzystanie kredytów, aby uniknąć nieoczekiwanych opłat

5. Wytyczne Dotyczące Treści

• Dostarczaj jasne, ustrukturyzowane dane wejściowe dla lepszego generowania slajdów
• Używaj odpowiednich motywów dla typu Twojej treści
• Określ język gdy potrzebne dla treści międzynarodowych
• Zachowuj treść zwięzłą dla optymalnego układu slajdów

Wsparcie i Zasoby

Dokumentacja i Zasoby

• Dokumentacja API - Interaktywna dokumentacja API i plac zabaw
• Galeria Szablonów - Przeglądaj dostępne szablony slajdów
• Informacje o Cenach - Pakiety kredytów i cennik
• Blog - Najnowsze aktualizacje i wskazówki

Uzyskiwanie Pomocy

• Plac Zabaw API: Testuj swoje wywołania API bezpośrednio w przeglądarce na 2slides.com/api
• Panel Konta: Zarządzaj wykorzystaniem kredytów na 2slides.com/account
• Wsparcie: Skontaktuj się z pomocą techniczną przez główną stronę internetową

Społeczność i Aktualizacje

• Aktualizacje Funkcji: Bądź na bieżąco z nowymi funkcjami i ulepszeniami
• Biblioteka Szablonów: Regularne dodawanie nowych profesjonalnych szablonów
• Ulepszenia API: Ciągłe usprawnienia wydajności i funkcji API

---

Podsumowanie

API 2slides zapewnia potężny i elastyczny sposób programowego generowania profesjonalnych prezentacji. Dzięki kompleksowemu zestawowi funkcji, solidnej obsłudze błędów i obszernej bibliotece szablonów, możesz zintegrować generowanie slajdów napędzane AI z dowolną aplikacją lub przepływem pracy.

Zacznij tworzyć niesamowite prezentacje już dziś z API 2slides! Odwiedź 2slides.com/api, aby uzyskać klucz API i rozpocząć tworzenie.