import requests

def get_shorts_data(url):
    try:
        response = requests.get(
            f"https://youtubescraper.in/api/v1/shorts",
            params={"url": url}
        )
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f"Error: {e}")
        return None

# Example usage
data = get_shorts_data("https://www.youtube.com/shorts/VIDEO_ID")
print(data)

# Get YouTube Shorts data
curl -X GET "https://youtubescraper.in/api/v1/shorts?url=https://www.youtube.com/shorts/VIDEO_ID"

# Search videos
curl -X GET "https://youtubescraper.in/api/v1/search?q=developer+tutorial"

# Get video comments
curl -X GET "https://youtubescraper.in/api/v1/video/comments?videoId=dQw4w9WgXcQ"

# Get channel playlists
curl -X GET "https://youtubescraper.in/api/v1/channel/playlists?url=https://www.youtube.com/@ChannelName"

# Get playlist videos
curl -X GET "https://youtubescraper.in/api/v1/playlist/videos?playlistId=PLAYLIST_ID"

import React, { useState, useEffect } from 'react';

function YouTubeShortsViewer() {
    const [shortsData, setShortsData] = useState(null);
    const [loading, setLoading] = useState(false);
    const [error, setError] = useState(null);

    const fetchShortsData = async (url) => {
        try {
            setLoading(true);
            const response = await fetch(`https://youtubescraper.in/api/v1/shorts?url=${encodeURIComponent(url)}`);
            const data = await response.json();
            setShortsData(data);
        } catch (err) {
            setError(err.message);
        } finally {
            setLoading(false);
        }
    };

    useEffect(() => {
        fetchShortsData('https://www.youtube.com/shorts/VIDEO_ID');
    }, []);

    return (
        

            {loading && 
Loading...
}
            {error && 
Error: {error}
}
            {shortsData && 
{JSON.stringify(shortsData, null, 2)}
}
        
    );
}

export default YouTubeShortsViewer;

import org.springframework.web.client.RestTemplate;
import org.springframework.http.ResponseEntity;
import java.util.Map;

public class YouTubeShortsService {

    private final RestTemplate restTemplate;

    public YouTubeShortsService(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    public Map<String, Object> getShortsData(String url) {
        String apiUrl = "https://youtubescraper.in/api/v1/shorts?url=" + url;

        ResponseEntity<Map> response = restTemplate.getForEntity(
            apiUrl,
            Map.class
        );

        return response.getBody();
    }

    // Example usage
    public static void main(String[] args) {
        RestTemplate restTemplate = new RestTemplate();
        YouTubeShortsService service = new YouTubeShortsService(restTemplate);

        Map<String, Object> data = service.getShortsData(
            "https://www.youtube.com/shorts/VIDEO_ID"
        );

        System.out.println(data);
    }
}

from django.http import JsonResponse
import requests

def get_shorts_data(request):
    video_url = request.GET.get('url', '')

    if not video_url:
        return JsonResponse({'error': 'URL parameter is required'}, status=400)

    try:
        response = requests.get(
            "https://youtubescraper.in/api/v1/shorts",
            params={'url': video_url}
        )
        response.raise_for_status()
        return JsonResponse(response.json())
    except requests.exceptions.RequestException as e:
        return JsonResponse({'error': str(e)}, status=500)

# urls.py
# path('api/youtube/shorts/', views.get_shorts_data, name='get_shorts_data')

require 'net/http'
require 'uri'
require 'json'

def get_shorts_data(url)
  uri = URI.parse("https://youtubescraper.in/api/v1/shorts")
  params = { url: url }
  uri.query = URI.encode_www_form(params)

  http = Net::HTTP.new(uri.host, uri.port)
  http.use_ssl = true
  request = Net::HTTP::Get.new(uri)

  response = http.request(request)

  if response.code == "200"
    JSON.parse(response.body)
  else
    { error: "Failed to fetch data: #{response.code}" }
  end
rescue => e
  { error: e.message }
end

# Example usage
data = get_shorts_data("https://www.youtube.com/shorts/VIDEO_ID")
puts data

use reqwest;
use serde_json::Value;
use urlencoding::encode;

#[tokio::main]
async fn get_shorts_data(url: &str) -> Result<Value, reqwest::Error> {
    let encoded_url = encode(url);
    let api_url = format!(
        "https://youtubescraper.in/api/v1/shorts?url={}",
        encoded_url
    );

    let response = reqwest::get(api_url).await?;
    let data = response.json::<Value>().await?;

    Ok(data)
}

// Example usage
fn main() {
    match get_shorts_data("https://www.youtube.com/shorts/VIDEO_ID") {
        Ok(data) => println!("{:?}", data),
        Err(e) => println!("Error: {}", e),
    }
}

const axios = require('axios');
const express = require('express');
const app = express();

// Express route to fetch YouTube Shorts data
app.get('/api/shorts', async (req, res) => {
    try {
        const url = req.query.url;
        if (!url) {
            return res.status(400).json({ error: 'URL parameter is required' });
        }

        const response = await axios.get(
            'https://youtubescraper.in/api/v1/shorts',
            { params: { url } }
        );

        res.json(response.data);
    } catch (error) {
        console.error('Error:', error.message);
        res.status(500).json({ error: 'Failed to fetch YouTube Shorts data' });
    }
});

// Start server
const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
    console.log(`Server running on port ${PORT}`);
});