Alertas de Conciertos con Songkick

1

Obtener API Key de Songkick

Regístrate en Songkick API y solicita tu API key.

Tu API Key de Songkick:

ℹ️ Nota: En producción, maneja la API key desde tu servidor, nunca en el frontend.

2

Buscar artistas

Obtén el ID de Songkick para tus artistas favoritos:

// Buscar artista por nombre
async function searchArtist(artistName, apiKey) {
    const response = await fetch(
        `https://api.songkick.com/api/3.0/search/artists.json?apikey=${apiKey}&query=${encodeURIComponent(artistName)}`
    );
    
    const data = await response.json();
    
    if (data.resultsPage.results.artist) {
        return data.resultsPage.results.artist[0]; // Tomar el primer resultado
    }
    
    return null;
}

// Ejemplo de uso
const artist = await searchArtist('Metallica', 'TU_API_KEY');
if (artist) {
    console.log('Artista encontrado:', artist.displayName);
    console.log('ID de Songkick:', artist.id);
}
                    

3

Buscar conciertos por artista

Obtén todos los eventos futuros de un artista:

// Obtener conciertos de un artista
async function getArtistConcerts(artistId, apiKey) {
    const response = await fetch(
        `https://api.songkick.com/api/3.0/artists/${artistId}/calendar.json?apikey=${apiKey}`
    );
    
    const data = await response.json();
    
    if (data.resultsPage.results.event) {
        return data.resultsPage.results.event;
    }
    
    return [];
}

// Obtener conciertos con más detalles
async function getDetailedConcerts(artistId, apiKey) {
    const concerts = await getArtistConcerts(artistId, apiKey);
    
    return concerts.map(concert => ({
        id: concert.id,
        artist: concert.performance[0]?.artist?.displayName,
        venue: concert.venue.displayName,
        city: concert.location.city,
        date: concert.start.date,
        time: concert.start.time,
        url: concert.uri,
        status: concert.status
    }));
}
                    

4

Filtrar por ubicación y distancia

Encuentra conciertos cerca de tu ubicación:

// Buscar conciertos cerca de una ubicación
async function getNearbyConcerts(lat, lng, apiKey, radius = 50) {
    const response = await fetch(
        `https://api.songkick.com/api/3.0/events.json?apikey=${apiKey}&location=geo:${lat},${lng}&radius=${radius}`
    );
    
    const data = await response.json();
    return data.resultsPage.results.event || [];
}

// Calcular distancia entre dos puntos
function calculateDistance(lat1, lng1, lat2, lng2) {
    const R = 6371; // Radio de la Tierra en km
    const dLat = (lat2 - lat1) * Math.PI / 180;
    const dLng = (lng2 - lng1) * Math.PI / 180;
    
    const a = Math.sin(dLat/2) * Math.sin(dLat/2) +
              Math.cos(lat1 * Math.PI / 180) * Math.cos(lat2 * Math.PI / 180) *
              Math.sin(dLng/2) * Math.sin(dLng/2);
    
    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a));
    return R * c;
}

// Sistema completo de alertas
class ConcertAlertSystem {
    constructor(apiKey) {
        this.apiKey = apiKey;
        this.trackedArtists = new Map();
        this.userLocation = null;
    }

    async addArtist(artistName) {
        const artist = await searchArtist(artistName, this.apiKey);
        if (artist) {
            this.trackedArtists.set(artist.id, {
                id: artist.id,
                name: artist.displayName,
                image: artist.image
            });
            return true;
        }
        return false;
    }

    async checkConcerts() {
        const allConcerts = [];
        
        for (const [artistId, artistInfo] of this.trackedArtists) {
            const concerts = await getDetailedConcerts(artistId, this.apiKey);
            
            // Filtrar por ubicación si está configurada
            if (this.userLocation) {
                const nearbyConcerts = concerts.filter(concert => {
                    const distance = calculateDistance(
                        this.userLocation.lat,
                        this.userLocation.lng,
                        concert.venue.lat,
                        concert.venue.lng
                    );
                    return distance <= this.userLocation.radius;
                });
                allConcerts.push(...nearbyConcerts);
            } else {
                allConcerts.push(...concerts);
            }
        }
        
        return allConcerts;
    }
}
                    

5

Configurar sistema de alertas

Implementa notificaciones y gestión de alertas:

// Sistema de alertas con persistencia
class ConcertAlertManager {
    constructor(apiKey, notificationService) {
        this.alertSystem = new ConcertAlertSystem(apiKey);
        this.notificationService = notificationService;
        this.alertedConcerts = this.loadAlertedConcerts();
    }

    async setupAlerts(artists, location) {
        // Añadir artistas
        for (const artist of artists) {
            await this.alertSystem.addArtist(artist);
        }
        
        // Configurar ubicación
        this.alertSystem.userLocation = location;
        
        // Guardar configuración
        this.saveConfiguration();
    }

    async checkAndAlert() {
        const concerts = await this.alertSystem.checkConcerts();
        const newConcerts = concerts.filter(concert => 
            !this.alertedConcerts.has(concert.id)
        );
        
        // Enviar notificaciones
        for (const concert of newConcerts) {
            await this.sendAlert(concert);
            this.alertedConcerts.set(concert.id, {
                concert: concert,
                alertedAt: new Date()
            });
        }
        
        this.saveAlertedConcerts();
        return newConcerts;
    }

    async sendAlert(concert) {
        const message = this.formatAlertMessage(concert);
        
        // Enviar notificación (email, push, etc.)
        await this.notificationService.send({
            title: `¡Concierto de ${concert.artist} anunciado!`,
            message: message,
            data: {
                type: 'concert_alert',
                concert: concert
            }
        });
    }

    formatAlertMessage(concert) {
        const date = new Date(concert.date).toLocaleDateString('es-ES', {
            weekday: 'long',
            year: 'numeric',
            month: 'long',
            day: 'numeric'
        });
        
        return `
🎸 ¡Concierto de ${concert.artist}!

📅 Fecha: ${date}
📍 Lugar: ${concert.venue}, ${concert.city}
🎫 Entradas: ${concert.url}

¡No te lo pierdas!
        `.trim();
    }

    // Persistencia en localStorage
    loadAlertedConcerts() {
        const stored = localStorage.getItem('alertedConcerts');
        return stored ? new Map(JSON.parse(stored)) : new Map();
    }

    saveAlertedConcerts() {
        localStorage.setItem('alertedConcerts', JSON.stringify([...this.alertedConcerts]));
    }
}

// Programar verificación periódica
function scheduleConcertChecks(alertManager, intervalHours = 6) {
    // Verificar inmediatamente
    alertManager.checkAndAlert();
    
    // Programar verificaciones
    setInterval(() => {
        alertManager.checkAndAlert();
    }, intervalHours * 60 * 60 * 1000);
}
                    

🎫 Crear Alertas de Conciertos con Songkick

📋 ¿Qué aprenderás?

🚀 Guía Paso a Paso

Obtener API Key de Songkick

Buscar artistas

Buscar conciertos por artista

Filtrar por ubicación y distancia

Configurar sistema de alertas

🎯 Demo en Vivo

Configuración de Alertas

💡 Mejores Prácticas

🚀 Próximos Pasos