Practical SellerMagnetAPI Code Examples

const axios = require('axios');

async function fetchAmazonProductStatistics(apiKey, asin, marketplaceId, retries = 3) {
    const url = `https://sellermagnet-api.com/amazon-product-statistics`;
    const headers = {
        'Authorization': `Bearer ${apiKey}`,
        'Content-Type': 'application/json'
    };
    const params = {
        
        asin: asin,
        
        marketplaceId: marketplaceId,
        
    };

    for (let attempt = 0; attempt < retries; attempt++) {
        try {
            const response = await axios.get(url, { headers, params, timeout: 10000 });
            return response.data;
        } catch (error) {
            console.error(`Attempt ${attempt + 1} failed: ${error.message}`);
            if (attempt + 1 === retries) throw new Error('Max retries reached');
            await new Promise(resolve => setTimeout(resolve, 2 ** attempt * 1000));
        }
    }
}

// Example usage
(async () => {
    try {
        const result = await fetchAmazonProductStatistics(
            'YOUR_API_KEY',
            
            "Product ASIN "B08N5WRWNW"",
            
            "A1PA6795UKMFR9",
            
        );
        console.log(result);
    } catch (error) {
        console.error(`Error: ${error.message}`);
    }
})();
                                    

#!/bin/bash

API_KEY="YOUR_API_KEY"
URL="https://sellermagnet-api.com/amazon-product-statistics"
PARAMS="asin=Product%20ASIN%20%22B08N5WRWNW%22&marketplaceId=A1PA6795UKMFR9&api_key=YOUR_API_KEY"

# Make the API request with retry logic
for i in {1..3}; do
    RESPONSE=$(curl -s -X GET "${URL}?${PARAMS}" \
        -H "Authorization: Bearer ${API_KEY}" \
        -H "Content-Type: application/json")
    if [ $? -eq 0 ]; then
        echo "${RESPONSE}"
        exit 0
    else
        echo "Attempt $i failed"
        sleep $((2 ** $i))
    fi
done
echo "Error: Max retries reached"
exit 1
                                    

const axios = require('axios');

async function fetchAmazonASINConverter(apiKey, asin, marketplaceId, conversion_direction, retries = 3) {
    const url = `https://sellermagnet-api.com/amazon-asin-converter`;
    const headers = {
        'Authorization': `Bearer ${apiKey}`,
        'Content-Type': 'application/json'
    };
    const params = {
        
        asin: asin,
        
        marketplaceId: marketplaceId,
        
        conversion_direction: conversion_direction,
        
    };

    for (let attempt = 0; attempt < retries; attempt++) {
        try {
            const response = await axios.get(url, { headers, params, timeout: 10000 });
            return response.data;
        } catch (error) {
            console.error(`Attempt ${attempt + 1} failed: ${error.message}`);
            if (attempt + 1 === retries) throw new Error('Max retries reached');
            await new Promise(resolve => setTimeout(resolve, 2 ** attempt * 1000));
        }
    }
}

// Example usage
(async () => {
    try {
        const result = await fetchAmazonASINConverter(
            'YOUR_API_KEY',
            
            "ASIN or EAN to convert "B08N5WRWNW" or "9781234567890"",
            
            "A1PA6795UKMFR9",
            
            "asin-to-ean",
            
        );
        console.log(result);
    } catch (error) {
        console.error(`Error: ${error.message}`);
    }
})();
                                    

#!/bin/bash

API_KEY="YOUR_API_KEY"
URL="https://sellermagnet-api.com/amazon-asin-converter"
PARAMS="asin=ASIN%20or%20EAN%20to%20convert%20%22B08N5WRWNW%22%20or%20%229781234567890%22&marketplaceId=A1PA6795UKMFR9&conversion_direction=asin-to-ean&api_key=YOUR_API_KEY"

# Make the API request with retry logic
for i in {1..3}; do
    RESPONSE=$(curl -s -X GET "${URL}?${PARAMS}" \
        -H "Authorization: Bearer ${API_KEY}" \
        -H "Content-Type: application/json")
    if [ $? -eq 0 ]; then
        echo "${RESPONSE}"
        exit 0
    else
        echo "Attempt $i failed"
        sleep $((2 ** $i))
    fi
done
echo "Error: Max retries reached"
exit 1
                                    

const axios = require('axios');

async function fetchGetAmazonSellerReview(apiKey, sellerId, marketplaceId, retries = 3) {
    const url = `https://sellermagnet-api.com/amazon-seller-review`;
    const headers = {
        'Authorization': `Bearer ${apiKey}`,
        'Content-Type': 'application/json'
    };
    const params = {
        
        sellerId: sellerId,
        
        marketplaceId: marketplaceId,
        
    };

    for (let attempt = 0; attempt < retries; attempt++) {
        try {
            const response = await axios.get(url, { headers, params, timeout: 10000 });
            return response.data;
        } catch (error) {
            console.error(`Attempt ${attempt + 1} failed: ${error.message}`);
            if (attempt + 1 === retries) throw new Error('Max retries reached');
            await new Promise(resolve => setTimeout(resolve, 2 ** attempt * 1000));
        }
    }
}

// Example usage
(async () => {
    try {
        const result = await fetchGetAmazonSellerReview(
            'YOUR_API_KEY',
            
            "Seller ID "A1B2C3D4E5F6G7"",
            
            "A1PA6795UKMFR9",
            
        );
        console.log(result);
    } catch (error) {
        console.error(`Error: ${error.message}`);
    }
})();
                                    

#!/bin/bash

API_KEY="YOUR_API_KEY"
URL="https://sellermagnet-api.com/amazon-seller-review"
PARAMS="sellerId=Seller%20ID%20%22A1B2C3D4E5F6G7%22&marketplaceId=A1PA6795UKMFR9&api_key=YOUR_API_KEY"

# Make the API request with retry logic
for i in {1..3}; do
    RESPONSE=$(curl -s -X GET "${URL}?${PARAMS}" \
        -H "Authorization: Bearer ${API_KEY}" \
        -H "Content-Type: application/json")
    if [ $? -eq 0 ]; then
        echo "${RESPONSE}"
        exit 0
    else
        echo "Attempt $i failed"
        sleep $((2 ** $i))
    fi
done
echo "Error: Max retries reached"
exit 1
                                    

const axios = require('axios');

async function fetchGetAmazonProduct(apiKey, asin, marketplaceId, retries = 3) {
    const url = `https://sellermagnet-api.com/amazon-product-lookup`;
    const headers = {
        'Authorization': `Bearer ${apiKey}`,
        'Content-Type': 'application/json'
    };
    const params = {
        
        asin: asin,
        
        marketplaceId: marketplaceId,
        
    };

    for (let attempt = 0; attempt < retries; attempt++) {
        try {
            const response = await axios.get(url, { headers, params, timeout: 10000 });
            return response.data;
        } catch (error) {
            console.error(`Attempt ${attempt + 1} failed: ${error.message}`);
            if (attempt + 1 === retries) throw new Error('Max retries reached');
            await new Promise(resolve => setTimeout(resolve, 2 ** attempt * 1000));
        }
    }
}

// Example usage
(async () => {
    try {
        const result = await fetchGetAmazonProduct(
            'YOUR_API_KEY',
            
            "Product ASIN "B08N5WRWNW"",
            
            "A1PA6795UKMFR9",
            
        );
        console.log(result);
    } catch (error) {
        console.error(`Error: ${error.message}`);
    }
})();
                                    

#!/bin/bash

API_KEY="YOUR_API_KEY"
URL="https://sellermagnet-api.com/amazon-product-lookup"
PARAMS="asin=Product%20ASIN%20%22B08N5WRWNW%22&marketplaceId=A1PA6795UKMFR9&api_key=YOUR_API_KEY"

# Make the API request with retry logic
for i in {1..3}; do
    RESPONSE=$(curl -s -X GET "${URL}?${PARAMS}" \
        -H "Authorization: Bearer ${API_KEY}" \
        -H "Content-Type: application/json")
    if [ $? -eq 0 ]; then
        echo "${RESPONSE}"
        exit 0
    else
        echo "Attempt $i failed"
        sleep $((2 ** $i))
    fi
done
echo "Error: Max retries reached"
exit 1
                                    

const axios = require('axios');

async function fetchGetAmazonProductOffers(apiKey, asin, marketplaceId, count, retries = 3) {
    const url = `https://sellermagnet-api.com/amazon-product-offers`;
    const headers = {
        'Authorization': `Bearer ${apiKey}`,
        'Content-Type': 'application/json'
    };
    const params = {
        
        asin: asin,
        
        marketplaceId: marketplaceId,
        
        count: count,
        
    };

    for (let attempt = 0; attempt < retries; attempt++) {
        try {
            const response = await axios.get(url, { headers, params, timeout: 10000 });
            return response.data;
        } catch (error) {
            console.error(`Attempt ${attempt + 1} failed: ${error.message}`);
            if (attempt + 1 === retries) throw new Error('Max retries reached');
            await new Promise(resolve => setTimeout(resolve, 2 ** attempt * 1000));
        }
    }
}

// Example usage
(async () => {
    try {
        const result = await fetchGetAmazonProductOffers(
            'YOUR_API_KEY',
            
            "asin",
            
            "A1PA6795UKMFR9",
            
            "30",
            
        );
        console.log(result);
    } catch (error) {
        console.error(`Error: ${error.message}`);
    }
})();
                                    

#!/bin/bash

API_KEY="YOUR_API_KEY"
URL="https://sellermagnet-api.com/amazon-product-offers"
PARAMS="asin=asin&marketplaceId=A1PA6795UKMFR9&count=30&api_key=YOUR_API_KEY"

# Make the API request with retry logic
for i in {1..3}; do
    RESPONSE=$(curl -s -X GET "${URL}?${PARAMS}" \
        -H "Authorization: Bearer ${API_KEY}" \
        -H "Content-Type: application/json")
    if [ $? -eq 0 ]; then
        echo "${RESPONSE}"
        exit 0
    else
        echo "Attempt $i failed"
        sleep $((2 ** $i))
    fi
done
echo "Error: Max retries reached"
exit 1
                                    

const axios = require('axios');

async function fetchGetAmazonMarketplaces(apiKey, retries = 3) {
    const url = `https://sellermagnet-api.com/amazon-get-marketplaces`;
    const headers = {
        'Authorization': `Bearer ${apiKey}`,
        'Content-Type': 'application/json'
    };
    const params = {
        
    };

    for (let attempt = 0; attempt < retries; attempt++) {
        try {
            const response = await axios.get(url, { headers, params, timeout: 10000 });
            return response.data;
        } catch (error) {
            console.error(`Attempt ${attempt + 1} failed: ${error.message}`);
            if (attempt + 1 === retries) throw new Error('Max retries reached');
            await new Promise(resolve => setTimeout(resolve, 2 ** attempt * 1000));
        }
    }
}

// Example usage
(async () => {
    try {
        const result = await fetchGetAmazonMarketplaces(
            'YOUR_API_KEY',
            
        );
        console.log(result);
    } catch (error) {
        console.error(`Error: ${error.message}`);
    }
})();
                                    

#!/bin/bash

API_KEY="YOUR_API_KEY"
URL="https://sellermagnet-api.com/amazon-get-marketplaces"
PARAMS="api_key=YOUR_API_KEY"

# Make the API request with retry logic
for i in {1..3}; do
    RESPONSE=$(curl -s -X GET "${URL}?${PARAMS}" \
        -H "Authorization: Bearer ${API_KEY}" \
        -H "Content-Type: application/json")
    if [ $? -eq 0 ]; then
        echo "${RESPONSE}"
        exit 0
    else
        echo "Attempt $i failed"
        sleep $((2 ** $i))
    fi
done
echo "Error: Max retries reached"
exit 1
                                    

const axios = require('axios');

async function fetchSearchAmazon(apiKey, q, marketplaceId, count, retries = 3) {
    const url = `https://sellermagnet-api.com/amazon-search`;
    const headers = {
        'Authorization': `Bearer ${apiKey}`,
        'Content-Type': 'application/json'
    };
    const params = {
        
        q: q,
        
        marketplaceId: marketplaceId,
        
        count: count,
        
    };

    for (let attempt = 0; attempt < retries; attempt++) {
        try {
            const response = await axios.get(url, { headers, params, timeout: 10000 });
            return response.data;
        } catch (error) {
            console.error(`Attempt ${attempt + 1} failed: ${error.message}`);
            if (attempt + 1 === retries) throw new Error('Max retries reached');
            await new Promise(resolve => setTimeout(resolve, 2 ** attempt * 1000));
        }
    }
}

// Example usage
(async () => {
    try {
        const result = await fetchSearchAmazon(
            'YOUR_API_KEY',
            
            "Search query "phone"",
            
            "Marketplace ID "A1PA6795UKMFR9"",
            
            "30",
            
        );
        console.log(result);
    } catch (error) {
        console.error(`Error: ${error.message}`);
    }
})();
                                    

#!/bin/bash

API_KEY="YOUR_API_KEY"
URL="https://sellermagnet-api.com/amazon-search"
PARAMS="q=Search%20query%20%22phone%22&marketplaceId=Marketplace%20ID%20%22A1PA6795UKMFR9%22&count=30&api_key=YOUR_API_KEY"

# Make the API request with retry logic
for i in {1..3}; do
    RESPONSE=$(curl -s -X GET "${URL}?${PARAMS}" \
        -H "Authorization: Bearer ${API_KEY}" \
        -H "Content-Type: application/json")
    if [ $? -eq 0 ]; then
        echo "${RESPONSE}"
        exit 0
    else
        echo "Attempt $i failed"
        sleep $((2 ** $i))
    fi
done
echo "Error: Max retries reached"
exit 1
                                    

const axios = require('axios');

async function fetchGetAmazonBestsellers(apiKey, category_id, marketplaceId, count, retries = 3) {
    const url = `https://sellermagnet-api.com/amazon-bestsellers`;
    const headers = {
        'Authorization': `Bearer ${apiKey}`,
        'Content-Type': 'application/json'
    };
    const params = {
        
        category_id: category_id,
        
        marketplaceId: marketplaceId,
        
        count: count,
        
    };

    for (let attempt = 0; attempt < retries; attempt++) {
        try {
            const response = await axios.get(url, { headers, params, timeout: 10000 });
            return response.data;
        } catch (error) {
            console.error(`Attempt ${attempt + 1} failed: ${error.message}`);
            if (attempt + 1 === retries) throw new Error('Max retries reached');
            await new Promise(resolve => setTimeout(resolve, 2 ** attempt * 1000));
        }
    }
}

// Example usage
(async () => {
    try {
        const result = await fetchGetAmazonBestsellers(
            'YOUR_API_KEY',
            
            "Category ID "electronics"",
            
            "A1PA6795UKMFR9",
            
            "30",
            
        );
        console.log(result);
    } catch (error) {
        console.error(`Error: ${error.message}`);
    }
})();
                                    

#!/bin/bash

API_KEY="YOUR_API_KEY"
URL="https://sellermagnet-api.com/amazon-bestsellers"
PARAMS="category_id=Category%20ID%20%22electronics%22&marketplaceId=A1PA6795UKMFR9&count=30&api_key=YOUR_API_KEY"

# Make the API request with retry logic
for i in {1..3}; do
    RESPONSE=$(curl -s -X GET "${URL}?${PARAMS}" \
        -H "Authorization: Bearer ${API_KEY}" \
        -H "Content-Type: application/json")
    if [ $? -eq 0 ]; then
        echo "${RESPONSE}"
        exit 0
    else
        echo "Attempt $i failed"
        sleep $((2 ** $i))
    fi
done
echo "Error: Max retries reached"
exit 1
                                    

const axios = require('axios');

async function fetchGetAmazonDealsCategories(apiKey, marketplaceId, retries = 3) {
    const url = `https://sellermagnet-api.com/amazon-deals-categories`;
    const headers = {
        'Authorization': `Bearer ${apiKey}`,
        'Content-Type': 'application/json'
    };
    const params = {
        
        marketplaceId: marketplaceId,
        
    };

    for (let attempt = 0; attempt < retries; attempt++) {
        try {
            const response = await axios.get(url, { headers, params, timeout: 10000 });
            return response.data;
        } catch (error) {
            console.error(`Attempt ${attempt + 1} failed: ${error.message}`);
            if (attempt + 1 === retries) throw new Error('Max retries reached');
            await new Promise(resolve => setTimeout(resolve, 2 ** attempt * 1000));
        }
    }
}

// Example usage
(async () => {
    try {
        const result = await fetchGetAmazonDealsCategories(
            'YOUR_API_KEY',
            
            "A1PA6795UKMFR9",
            
        );
        console.log(result);
    } catch (error) {
        console.error(`Error: ${error.message}`);
    }
})();
                                    

#!/bin/bash

API_KEY="YOUR_API_KEY"
URL="https://sellermagnet-api.com/amazon-deals-categories"
PARAMS="marketplaceId=A1PA6795UKMFR9&api_key=YOUR_API_KEY"

# Make the API request with retry logic
for i in {1..3}; do
    RESPONSE=$(curl -s -X GET "${URL}?${PARAMS}" \
        -H "Authorization: Bearer ${API_KEY}" \
        -H "Content-Type: application/json")
    if [ $? -eq 0 ]; then
        echo "${RESPONSE}"
        exit 0
    else
        echo "Attempt $i failed"
        sleep $((2 ** $i))
    fi
done
echo "Error: Max retries reached"
exit 1