REST API

Copy{
  "successful": true,
  "status": "processing",
  "waiting": true,
  "article_id": "artl_abc123",
  "player_url": "https://everlit.audio/embeds/artl_abc123",
  "message": "Everlit audio conversion is still in progress."
}

Copy{
  "successful": false,
  "status": "error",
  "reason": "Unable to fetch the article content."
}

cURL Commands

Copy# Initiate conversion
curl -X POST https://creator.everlit.audio/audio/auto \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -d '{
    "url": "https://example.com/article",
    "publication_id": "pblc_abc123xyz",
    "conversation_mode": true,
    "sonic_optimizer": true
  }'

# Check status (encode the parameters first)
EVP=$(echo -n '{"url":"https://example.com/article","publication_id":"pblc_abc123xyz"}' | \
  base64 | tr '+/' '-_' | tr -d '=')

curl "https://creator.everlit.audio/audio/auto/check?evp=$EVP"

Python Implementation

Copyimport requests
import json
import base64
import time

class EverlitAutoAudio:
    BASE_URL = 'https://creator.everlit.audio'

    def __init__(self, publication_id, api_token=None):
        self.publication_id = publication_id
        self.api_token = api_token

    def convert_article(self, url, **options):
        # Check status
        status = self.check_status(url)
        if status.get('embed'):
            return status['embed']

        # Initiate if needed
        if status.get('create'):
            self.initiate_conversion(url, **options)

        # Poll for completion
        return self.poll_for_completion(url)

    def check_status(self, url):
        params = {'url': url, 'publication_id': self.publication_id}
        evp = base64.urlsafe_b64encode(
            json.dumps(params).encode()
        ).decode().rstrip('=')

        response = requests.get(
            f'{self.BASE_URL}/audio/auto/check',
            params={'evp': evp}
        )
        return response.json()

    def initiate_conversion(self, url, **options):
        headers = {'Content-Type': 'application/json'}
        if self.api_token:
            headers['Authorization'] = f'Bearer {self.api_token}'

        payload = {
            'url': url,
            'publication_id': self.publication_id,
            **options
        }

        response = requests.post(
            f'{self.BASE_URL}/audio/auto',
            headers=headers,
            json=payload
        )
        return response.json()

    def poll_for_completion(self, url, max_attempts=60):
        for _ in range(max_attempts):
            time.sleep(5)
            status = self.check_status(url)
            if status.get('embed'):
                return status['embed']
        raise Exception('Conversion timeout')

# Usage
client = EverlitAutoAudio('pblc_abc123xyz', 'your_token')
embed = client.convert_article(
    'https://example.com/article',
    conversation_mode=True,
    sonic_optimizer=True
)
print(embed)

Ruby Implementation

Copyrequire 'net/http'
require 'json'
require 'base64'

class EverlitAutoAudio
  BASE_URL = 'https://creator.everlit.audio'

  def initialize(publication_id, api_token = nil)
    @publication_id = publication_id
    @api_token = api_token
  end

  def convert_article(url, options = {})
    status = check_status(url)
    return status[:embed] if status[:embed]

    initiate_conversion(url, options) if status[:create]
    poll_for_completion(url)
  end

  def check_status(url)
    params = { url: url, publication_id: @publication_id }
    evp = Base64.urlsafe_encode64(params.to_json, padding: false)

    uri = URI("#{BASE_URL}/audio/auto/check?evp=#{evp}")
    response = Net::HTTP.get_response(uri)
    JSON.parse(response.body, symbolize_names: true)
  end

  def initiate_conversion(url, options = {})
    uri = URI("#{BASE_URL}/audio/auto")
    request = Net::HTTP::Post.new(uri)
    request['Content-Type'] = 'application/json'
    request['Authorization'] = "Bearer #{@api_token}" if @api_token

    body = { url: url, publication_id: @publication_id }.merge(options)
    request.body = body.to_json

    response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
      http.request(request)
    end

    JSON.parse(response.body, symbolize_names: true)
  end

  def poll_for_completion(url, max_attempts = 60)
    max_attempts.times do
      sleep(5)
      status = check_status(url)
      return status[:embed] if status[:embed]
    end
    raise "Conversion timeout"
  end
end

# Usage
client = EverlitAutoAudio.new('pblc_abc123xyz', 'your_token')
embed = client.convert_article(
  'https://example.com/article',
  conversation_mode: true,
  sonic_optimizer: true
)
puts embed