Sur d’autres sites (11134)

• Why does my ffmpeg audio sound slower and deeper - sample rate mismatch

  4 septembre 2020, par yogesh zinzu

  ok so this is a discord bot to record voice chat
https://hatebin.com/hgjlazacri
Now the bot works perfectly fine but the issue is that the audio sounds a bit deeper and slower than normal.. Why does it happen ? how can I make the audio sound 1:1..

  


  


  


  const Discord = require('discord.js');
const client = new Discord.Client();
const ffmpegInstaller = require('@ffmpeg-installer/ffmpeg');
const ffmpeg = require('fluent-ffmpeg');
ffmpeg.setFfmpegPath(ffmpegInstaller.path);
const fs = require('fs-extra')
const mergeStream = require('merge-stream');
const config = require('./config.json');
const { getAudioDurationInSeconds } = require('get-audio-duration');
const cp = require('child_process');
const path1 = require('path');
const Enmap = require('enmap');
const UserRecords = require("./models/userrecords.js")
const ServerRecords = require("./models/serverrecords.js")
let prefix = `$`
class Readable extends require('stream').Readable { _read() {} }
let recording = false;
let currently_recording = {};
let mp3Paths = [];
const silence_buffer = new Uint8Array(3840);
const express = require('express')
const app = express()
const port = 3000
const publicIP = require('public-ip')
const { program } = require('commander');
const { path } = require('@ffmpeg-installer/ffmpeg');
const version = '0.0.1'
program.version(version);
let debug = false
let runProd = false
let fqdn = "";
const mongoose = require("mongoose");
const MongoClient = require('mongodb').MongoClient;
mongoose.connect('SECRRET',{
  useNewUrlParser: true
}, function(err){
  if(err){
    console.log(err);
  }else{
    console.log("Database connection initiated");
  }
});
require("dotenv").config()
function bufferToStream(buffer) {
    let stream = new Readable();
    stream.push(buffer);
    return stream;
}





client.commands = new Enmap();

client.on('ready', async () => {
    console.log(`Logged in as ${client.user.tag}`);

    let host = "localhost"

    

    let ip = await publicIP.v4();

    let protocol = "http";
    if (!runProd) {
        host = "localhost"
    } else {
        host = `35.226.244.186`;
    }
    fqdn = `${protocol}://${host}:${port}`
    app.listen(port, `0.0.0.0`, () => {
        console.log(`Listening on port ${port} for ${host} at fqdn ${fqdn}`)
    })
});
let randomArr = []
let finalArrWithIds = []
let variable = 0
client.on('message', async message => {
    console.log(`fuck`);
    if(message.content === `$record`){
        mp3Paths = []
        finalArrWithIds = []
        let membersToScrape = Array.from(message.member.voice.channel.members.values());
        membersToScrape.forEach((member) => {
            if(member.id === `749250882830598235`) {
                console.log(`botid`);
            }
            else {
                finalArrWithIds.push(member.id)
            }
            
        })
        const randomNumber = Math.floor(Math.random() * 100)
        randomArr = []
        randomArr.push(randomNumber)
    }
   
    
    const generateSilentData = async (silentStream, memberID) => {
        console.log(`recordingnow`)
        while(recording) {
            if (!currently_recording[memberID]) {
                silentStream.push(silence_buffer);
            }
            await new Promise(r => setTimeout(r, 20));
        }
        return "done";
    }
    console.log(generateSilentData, `status`)
    function generateOutputFile(channelID, memberID) {
        const dir = `./recordings/${channelID}/${memberID}`;
        fs.ensureDirSync(dir);
        const fileName = `${dir}/${randomArr[0]}.aac`;
        console.log(`${fileName} ---------------------------`);
        return fs.createWriteStream(fileName);
    }
    
    if (!fs.existsSync("public")) {
        fs.mkdirSync("public");
    }
    app.use("/public", express.static("./public"));
  if (!message.guild) return;

  if (message.content === config.prefix + config.record_command) {
    if (recording) {
        message.reply("bot is already recording");
        return
    }
    if (message.member.voice.channel) {
        recording = true;
        const connection = await message.member.voice.channel.join();
        const dispatcher = connection.play('./audio.mp3');

        connection.on('speaking', (user, speaking) => {
            if (speaking.has('SPEAKING')) {
                currently_recording[user.id] = true;
            } else {
                currently_recording[user.id] = false;
            }
        })


        let members = Array.from(message.member.voice.channel.members.values());
        members.forEach((member) => {

            if (member.id != client.user.id) {
                let memberStream = connection.receiver.createStream(member, {mode : 'pcm', end : 'manual'})

                let outputFile = generateOutputFile(message.member.voice.channel.id, member.id);
                console.log(outputFile, `outputfile here`);
                mp3Paths.push(outputFile.path);
                    

                silence_stream = bufferToStream(new Uint8Array(0));
                generateSilentData(silence_stream, member.id).then(data => console.log(data));
                let combinedStream = mergeStream(silence_stream, memberStream);

                ffmpeg(combinedStream)
                    .inputFormat('s32le')
                    .audioFrequency(44100)
                    .audioChannels(2)
                    .on('error', (error) => {console.log(error)})
                    .audioCodec('aac')
                    .format('adts') 
                    .pipe(outputFile)
                    
            }
        })
    } else {
      message.reply('You need to join a voice channel first!');
    }
  }

  if (message.content === config.prefix + config.stop_command) {

    let date = new Date();
    let dd = String(date.getDate()).padStart(2, '0');
    let mm = String(date.getMonth() + 1).padStart(2, '0'); 
    let yyyy = date.getFullYear();
    date = mm + '/' + dd + '/' + yyyy;





    let currentVoiceChannel = message.member.voice.channel;
    if (currentVoiceChannel) {
        recording = false;
        await currentVoiceChannel.leave();

        let mergedOutputFolder = './recordings/' + message.member.voice.channel.id + `/${randomArr[0]}/`;
        fs.ensureDirSync(mergedOutputFolder);
        let file_name = `${randomArr[0]}` + '.aac';
        let mergedOutputFile = mergedOutputFolder + file_name;
    
        
    let download_path = message.member.voice.channel.id + `/${randomArr[0]}/` + file_name;

        let mixedOutput = new ffmpeg();
        console.log(mp3Paths, `mp3pathshere`);
        mp3Paths.forEach((mp3Path) => {
             mixedOutput.addInput(mp3Path);
            
        })
        console.log(mp3Paths);
        //mixedOutput.complexFilter('amix=inputs=2:duration=longest');
        mixedOutput.complexFilter('amix=inputs=' + mp3Paths.length + ':duration=longest');
        
        let processEmbed = new Discord.MessageEmbed().setTitle(`Audio Processing.`)
        processEmbed.addField(`Audio processing starting now..`, `Processing Audio`)
        processEmbed.setThumbnail(`https://media.discordapp.net/attachments/730811581046325348/748610998985818202/speaker.png`)
        processEmbed.setColor(` #00FFFF`)
        const processEmbedMsg = await message.channel.send(processEmbed)
        async function saveMp3(mixedData, outputMixed) {
            console.log(`${mixedData} MIXED `)
            
            
            
            return new Promise((resolve, reject) => {
                mixedData.on('error', reject).on('progress',
                async (progress) => {
                    
                    let processEmbedEdit = new Discord.MessageEmbed().setTitle(`Audio Processing.`)
                    processEmbedEdit.addField(`Processing: ${progress.targetSize} KB converted`, `Processing Audio`)
                    processEmbedEdit.setThumbnail(`https://media.discordapp.net/attachments/730811581046325348/748610998985818202/speaker.png`)
                    processEmbedEdit.setColor(` #00FFFF`)
                    processEmbedMsg.edit(processEmbedEdit)
                    console.log('Processing: ' + progress.targetSize + ' KB converted');
                }).on('end', () => {
                    console.log('Processing finished !');
                    resolve()
                }).saveToFile(outputMixed);
                console.log(`${outputMixed} IT IS HERE`);
            })
        }
        // mixedOutput.saveToFile(mergedOutputFile);
        await saveMp3(mixedOutput, mergedOutputFile);
        console.log(`${mixedOutput} IN HEREEEEEEE`);
        // We saved the recording, now copy the recording
        if (!fs.existsSync(`./public`)) {
            fs.mkdirSync(`./public`);
        }
        let sourceFile = `${__dirname}/recordings/${download_path}`
        console.log(`DOWNLOAD PATH HERE ${download_path}`)
        const guildName = message.guild.id;
        const serveExist = `/public/${guildName}`
        if (!fs.existsSync(`.${serveExist}`)) {
            fs.mkdirSync(`.${serveExist}`)
        }
        let destionationFile = `${__dirname}${serveExist}/${file_name}`

        let errorThrown = false
        try {
            fs.copySync(sourceFile, destionationFile);
        } catch (err) {
            errorThrown = true
            await message.channel.send(`Error: ${err.message}`)
        }
        const usersWithTag = finalArrWithIds.map(user => `\n <@${user}>`);
        let timeSpent = await getAudioDurationInSeconds(`public/${guildName}/${file_name}`)
        let timesSpentRound = Math.floor(timeSpent)
        let finalTimeSpent = timesSpentRound / 60
        let finalTimeForReal = Math.floor(finalTimeSpent)
        if(!errorThrown){
            //--------------------- server recording save START
            class GeneralRecords {
                constructor(generalLink, date, voice, time) {
                  this.generalLink = generalLink;
                  this.date = date;
                  this.note = `no note`;
                  this.voice = voice;
                  this.time = time
                }
              }
              let newGeneralRecordClassObject = new GeneralRecords(`${fqdn}/public/${guildName}/${file_name}`, date, usersWithTag, finalTimeForReal)
              let checkingServerRecord = await ServerRecords.exists({userid: `server`})
              if(checkingServerRecord === true){
                  existingServerRecord = await ServerRecords.findOne({userid: `server`})
                  existingServerRecord.content.push(newGeneralRecordClassObject)
                  await existingServerRecord.save()
              }
              if(checkingServerRecord === false){
                let serverRecord = new ServerRecords()
                serverRecord.userid = `server`
                serverRecord.content.push(newGeneralRecordClassObject)
                await serverRecord.save()
              }
              //--------------------- server recording save STOP
        }
        
        //--------------------- personal recording section START
        for( member of finalArrWithIds) {

        let personal_download_path = message.member.voice.channel.id + `/${member}/` + file_name;
        let sourceFilePersonal = `${__dirname}/recordings/${personal_download_path}`
        let destionationFilePersonal = `${__dirname}${serveExist}/${member}/${file_name}`
        await fs.copySync(sourceFilePersonal, destionationFilePersonal);
        const user = client.users.cache.get(member);
        console.log(user, `user here`);
        try {
            ffmpeg.setFfmpegPath(ffmpegInstaller.path);
          
            ffmpeg(`public/${guildName}/${member}/${file_name}`)
             .audioFilters('silenceremove=stop_periods=-1:stop_duration=1:stop_threshold=-90dB')
             .output(`public/${guildName}/${member}/personal-${file_name}`)
             .on(`end`, function () {
               console.log(`DONE`);
             })
             .on(`error`, function (error) {
               console.log(`An error occured` + error.message)
             })
             .run();
             
          }
          catch (error) {
          console.log(error)
          }
        

        // ----------------- SAVING PERSONAL RECORDING TO DATABASE START
        class PersonalRecords {
            constructor(generalLink, personalLink, date, time) {
              this.generalLink = generalLink;
              this.personalLink = personalLink;
              this.date = date;
              this.note = `no note`;
              this.time = time;
            }
          }
          let timeSpentPersonal = await getAudioDurationInSeconds(`public/${guildName}/${file_name}`)
          let timesSpentRoundPersonal = Math.floor(timeSpentPersonal)
          let finalTimeSpentPersonal = timesSpentRoundPersonal / 60
          let finalTimeForRealPersonal = Math.floor(finalTimeSpentPersonal)
          let newPersonalRecordClassObject = new PersonalRecords(`${fqdn}/public/${guildName}/${file_name}`, `${fqdn}/public/${guildName}/${member}/personal-${file_name}`, date, finalTimeForRealPersonal)

           let checkingUserRecord = await UserRecords.exists({userid: member})
              if(checkingUserRecord === true){
                  existingUserRecord = await UserRecords.findOne({userid: member})
                  existingUserRecord.content.push(newPersonalRecordClassObject)
                  await existingUserRecord.save()
              }
              if(checkingUserRecord === false){
                let newRecord = new UserRecords()
                newRecord.userid = member
                newRecord.content.push(newPersonalRecordClassObject)
                await newRecord.save()
              }


       
        // ----------------- SAVING PERSONAL RECORDING TO DATABASE END
       

        const endPersonalEmbed = new Discord.MessageEmbed().setTitle(`Your performance was amazing ! Review it here :D`)
        endPersonalEmbed.setColor('#9400D3')
        endPersonalEmbed.setThumbnail(`https://media.discordapp.net/attachments/730811581046325348/745381641324724294/vinyl.png`)
        endPersonalEmbed.addField(`1

• The Only 7 Lead Generation Tools You Need in 2024

  7 mars 2024, par Erin

  If you can’t get leads, you can’t get customers. To ensure you always have a steady stream of new customers (and revenue), you need to equip yourself with lead generation tools.

  Lead gen software does the heavy lifting for you so you can focus on providing great products and great services. With it, you’ll be able to turn more strangers into customers and grow your business.

  And you don’t need a ton of tools to get the job done, either. Consolidating your tech stack to a few select tools will help you get more done in less time (and with less confusion).

  In this article, we’ll analyse the top seven lead generation tools to help you grow your business in 2024.

  Let’s dive in.

  What is a lead generation tool ?

  A lead generation tool is software you can use to turn strangers into customers. It helps you draw customers into your sales funnel by learning their contact details, like their email address or phone number.

  

  Lead generation tools are great levers you can pull to drive high-quality leads. They remove the grunt work by automating the lead generation process. 

  Whether it’s through creating lead magnets, offering conversion rate analytics, helping you create high-quality forms or automating the lead follow-up process, lead generation tools can bring in new customers to grow your business.

  The top 7 lead generation tools in 2024

  To land more leads, you need to ensure you’re leveraging the right software. With so many to choose from, here’s just a handful of the best ones available :

  

  1. Matomo : Best conversion optimisation tool

  Matomo is an open-source website analytics tool dedicated to protecting user privacy and data. Trusted on over 1 million websites, the platform offers in-depth insights into your web traffic, including conversion data.

  

  Why Matomo ? Matomo is trusted by over 1 million websites, including the United Nations and the European Commission, making it the leading choice for privacy-focused web analytics.

  It comes equipped with a suite of conversion optimisation features to help you generate more leads. You can easily analyse your target audience’s behaviour while also respecting users’ privacy.

  Standout features : In-depth visitor tracking, From Analytics, Session Recordings, A/B Testing, Heatmaps Marketing Attribution, roll-up reporting (pulling data from multiple sites), Google Analytics importing. and more.

  Integrations : Cloudflare, WooCommerce, Squarespace, Shopify, Drupal, Magento, Vue, SharePoint, WordPress, Wix, Webflow, GoDaddy, Jimdo, Joomla, Kajabi. and more.

  Pricing : Starts free for Matomo On-Premise and increases to $23/month for Matomo Cloud (which includes a free 21-day trial with no credit card required).

  Pros

  • 100% accurate data with no data sampling
  • Leading web analytics tool for respecting visitor privacy
  • Compliant with the strictest privacy laws, like the GDPR
  • No need for cookie consent banner (except in the UK and Germany)
  • Wide range of advanced features to optimise your website and increase conversions
  • Cloud hosting and on-premise options for flexibility

  Cons

  • Matomo On-Premise requires technical expertise (but for the less technical, the Cloud option works instantly)
  • On-Premise plugins are an additional cost

  Try Matomo for Free

  Get the web insights you need, without compromising data accuracy.

  Start for free

  No credit card required

  2. HubSpot : Best all-in-one CRM for organising leads

  HubSpot is a customer relationship management (CRM) and marketing software with over 194,000 customers worldwide. This user-friendly platform is dedicated to helping businesses of all sizes manage leads and customers.

  

  Why HubSpot ? HubSpot Marketing integrates seamlessly with the HubSpot CRM to help with everything from lead capture to conversion. The platform also features a free version — a great starting place for lead generation and management.

  Standout features : A robust set of no-code lead gen tools, like ads, forms, customisable landing pages, lead capture templates for potential customers, email campaigns, analytics dashboards and a free CRM to track leads.

  Integrations : Google Ads, WordPress, Jotform, Facebook Ads, Magento, Shopify, Weebly, WordPress, Zapier and Drupal.

  Pricing : Starts free for anyone and increases to $800/month for a professional plan.

  Pros

  • User-friendly interface
  • All-in-one lead management solution
  • Easy integration with HubSpot CRM
  • Simple analytics for beginners
  • Includes landing page tools
  • Offers email marketing tools to nurture leads

  Cons

  • Free version has limited functionality
  • Expensive jump to paid plans

  3. Leadfeeder : Best for finding warm B2B leads

  Leadfeeder is a business-to-business (B2B) marketing tool that shows B2B brands which companies are visiting their websites and gives them contact information to reach out to the right decision-makers.

  

  Why Leadfeeder ? Leadfeeder simplifies outreach for B2B organisations because it shows you what businesses are interacting with your website. Rather than trying to reach out to completely cold leads, the tool highlights brands that are already checking out your content and offerings.

  Standout features : Many account-based marketing (ABM) tools enable you to discover B2B accounts with insights into when you should contact them after they visit your site, as well as their job titles. The platform also includes a range of features that notify you and your sales team when qualified B2B leads come to your site so that you can move to capture them quickly.

  Integrations : Zoho, Google Chat, Pipedrive, Salesforce, Google Looker Studio, ActiveCampaign, HubSpot, Mailchimp, Microsoft Dynamics and Slack.

  Pricing : Starts at $139/month (includes a 14-day free trial).

  Pros

  • Easily find prospective customers
  • Track website visitors and potential customers freely
  • Simple filtering capabilities

  Cons

  • Few integrations available
  • Can be difficult to contact customer support

  4. OptinMonster : Best all-in-one lead generation form tool

  Founded in 2013, OptinMonster has over 1.2 million users worldwide. It offers a wide range of lead gen tools led by robust form tools that turn your target audience into leads.

  

  Why OptinMonster ? The platform is one of the most reputable lead generation platforms available. With nearly 100 lead capture templates, it’s highly customisable to almost any business looking to begin capturing leads with different forms.

  Standout features : 95 customisable form templates, drag-and-drop builders, onsite retargeting, segmentation, A/B testing and exit-intent popups that present forms when a user is about to leave the site.

  Integrations : Constant Contact, ConvertKit, ActiveCampaign, Salesforce Pardot, Campaign Monitor, HubSpot, Jilt, Keap and Mailchimp.

  Pricing : Starts at $16/month (no free trial offered).

  Pros

  • Easy drag-and-drop form-builder
  • Wide range of form templates
  • Customisable forms for any business
  • Simple A/B testing to help optimise form performance

  Cons

  • No free trial available
  • Growth features, like onsite retargeting, are only available on higher-tiered plans

  5. Intercom : Best live chat tool for capturing leads

  Intercom is one of the top live chat tools for helping businesses maintain solid communication with their customers. Founded in 2011, this live chat platform serves over 25,000 users around the world with a simple, sophisticated experience and seamless lead generation features.

  

  Why Intercom ? Intercom is a live chat tool first. But many people don’t know it’s also a simple lead capture tool. When people think of lead generation, they think of static or popup forms. But Intercom allows you to capture forms directly within a live chat conversation.

  Standout features : Lead generation via live chat that allows you to naturally capture potential customers’ information to turn them into a lead. The tool also comes equipped with chatbots that can automate the communication and lead gen process on autopilot.

  Integrations : Pipedrive, Typeform, Google Analytics, Zapier, Calendly, Salesforce, Stripe, Campaign Monitor, Clearbit Reveal and HubSpot.

  Pricing : Starts at $39/month (with a 21-day free trial).

  Pros

  • Live chat lead gen capture
  • Chatbot lead generation automation
  • Wide range of integrations and apps
  • User-friendly interface

  Cons

  • Fairly expensive for small businesses
  • Customer support isn’t the fastest

  6. Callingly : Best for making inbound calls with leads

  Callingly is a sophisticated call software that lets you get the most out of every inbound call you get from leads. Founded in 2019, this software company gives valuable insights into your inbound call leads, pulling information from various integrations and forms.

  

  Why Callingly ? Callingly is a robust call software that gathers lead information through forms, lead magnets, landing pages and forms. The software also has intelligent routing, which sends a call to the most relevant salesperson.

  Standout features : Advanced lead routing ensures inbound leads are directed to the most appropriate sales rep based on their unique needs and geographic location. The tool is also equipped with call tracking, analytics, lead source tracking and more to help personalise the experience for quick capture and conversion of leads.

  Integrations : ClickFunnels, Pipedrive, Salesforce, Drip, Aircall, HubSpot, Jotform, OptinMonster, Unbounce and Zapier.

  Pricing : Starts at $49/month (with a 14-day free trial).

  Pros

  • Instantly see robust caller information based on previous interactions
  • Intelligent routing places leads with the right sales reps
  • Call recordings to capture data and transfer it into your CRM
  • Voicemail and caller ID capabilities
  • Reporting and analytics for performance tracking

  Cons

  • Doesn’t include lead segmentation
  • Limited customisations
  • No email integration

  7. Notion : Best for creating informational lead magnets

  Notion is one of the most popular collaboration tools on the Internet. Founded in 2013, the platform has over 35 million users worldwide. While it’s known primarily for its advanced note-taking capabilities, Notion is also a simple tool you can use to create informational lead magnets.

  

  Why Notion ? Notion is a simple yet powerful tool you can use to create almost anything. If you want to generate more leads, then creating a free info product with Notion is a simple and effective way to do that. It enables you to create ebooks, digital courses and video courses without having to rely on expensive software.

  Standout features : Documentation tools, note-taking, collaborative documents and duplication capabilities. It’s simple to create a high-value informational product, like an ebook or course with multiple chapters.

  Integrations : Audienceful, Miro, Momentum, Slack, ChatGPT, Clockify, Desktop.com, SureTriggers, Trello and Google Drive.

  Pricing : Starts at $8/month (no free trial available).

  Pros

  • Easy to create a digital product or lead magnet
  • Leads have access with a simple link
  • Lead magnet can be updated in real time
  • AI writing assistant
  • Drag-and-drop functionality
  • User-friendly interface
  • Low-cost pricing plans

  Cons

  • No free trial available (though there is a free version)
  • Search function could use some improvement
  • Performance isn’t the fastest

  Use Matomo to generate more leads

  If you want more leads, then you need to start tracking your website’s forms.

  With Matomo, you get access to features like Form Analytics, A/B Testing, Heatmaps, and Session Recordings to help with conversion rate optimisation.

  Recently, Concrete CMS leveraged Matomo’s funnel analysis feature to improve its lead capture. The CMS was then able to identify bottlenecks in user onboarding. Matomo’s insights showed that users were getting stuck at the address input stage of the form.

  By tweaking their form, Concrete CMS tripled their leads in just a few days.

  If you want to improve your lead generation, then get started with Matomo’s 21-day free trial today. No credit card required.

  Try Matomo for Free

  21 day free trial. No credit card required.

  
  

  Your email address
  

  Your website address
  

  Your Analytics subdomain will be .matomo.cloud (change)

  Choose your analytics subdomain
  

  .matomo.cloud

  I accept the terms and conditions and data processing agreement (DPA)

  
  Your information will be used to create an account on our cloud service. For more information please consult our privacy policy.
  
  
  

  Start improving your websites now

  

• Your 6-step guide to increasing acquisition

  2 juillet 2019, par Matomo Core Team — Analytics Tips
  Your 6-step guide to increasing acquisition

  Want to save time and money, as well as increase conversions and acquisition ? Matomo Analytics is here to help with that !

  Let’s start by helping you create a website visitors’ acquisition strategy, without it you might be going in blind and missing opportunities that might’ve been easily found in your metrics.

  To help you craft a strategy for your site, check out the steps below !

  Step one : Get familiar with the Acquisition feature

  The easiest way is to start with Matomo’s Acquisition feature itself. Discover and take action on the marketing channels with the biggest ROI for your business. You’ll learn :

  How to get traffic from external websites : Find out who’s helping you succeed from external websites and convince them to do more of it. Get more traffic by proactively asking for : paid sponsorships ; guest blog posts ; or spending more advertising on the particular website.

  

  About Social Networks : Which social media channels are connecting with the audience you want ? Take the guesswork out by using only the ones you need. By finding out which social channels your ideal audience prefers, you can generate shareable, convincing and engaging content to drive shares and traffic through to your site.

  Campaigns : This helps you understand which marketing campaign is working and which isn’t. You can then shift your efforts to effectively gain more visitors with less costs. Keep track of every ad and content piece you show across internal and external channels to see which has the biggest impact on your business objectives.

  Enhanced SEO : Every acquisition plan needs a focus on maximising your Search Engine Optimization (SEO) efforts. When it comes to getting conclusive search engine referrer metrics, you need to be sure you’re getting ALL the insights to drive your SEO strategy. See keyword position rankings, integrate Google, Bing and Yahoo search consoles, and no longer be restricted with “keyword not defined” showing up in your keywords reports.

  >> Watch Acquisition introduction video (playtime : 2.54 minutes)

  Step two : Set your goals and monitor conversion funnels

  Let the Goals feature guide you

  Goals are essential for building your marketing strategy and getting new customers. The more goals you track, the more you learn about behavioural changes and modify pathways to impact acquisitions over time. 

  Are you checking :

  • Which channels are converting the best for your business ?
  • Which cities/countries are most popular ?
  • What devices will attract the most visitors ?
  • How engaged your visitors are before converting ?

  This way you can see if your campaigns (SEO, PPC, signups, blogs etc.) or optimising efforts (A/B Testing, Funnels) have made an impact with the time and investment you’ve put in.

  >> Watch Goals introduction video (playtime : 2.04 minutes)

  The Funnels feature leads you to success

  Conversion funnels give you the big picture on whether your acquisition plans are paying off and where they may be falling short. If the ultimate goal of your site is to drive conversions, then each funnel can tell you how effectively you’re driving traffic through to your desired outcome.

  >> Watch Funnels introduction video (playtime : 2.29 minutes)

  

  Step three : Measure the success of every touchpoint in your customer’s journey

  Multi Attribution feature

  Accurately identify channels where visitors first engage with your business, as well as the final channel they came from, before purchasing your product/service. This helps you make smarter decisions when determining acquisition spend to accurately calculate the Customer Acquisition Cost (CAC). Here you no longer falsely over-estimate investment in failing marketing channels.

  >> Watch Multi Attribution introduction video (playtime : 2.28 minutes)

  Step four : For ecommerce sites, understand who your customers are to increase sales

  Ecommerce feature to significantly increase $ potential

  If your website’s overall purpose is to generate revenue, the Ecommerce feature gives you comprehensive insights into your customer’s purchasing behaviours.

  This heavily reduces your risks when marketing products to potential customers as you’ll understand who to target, what to target them with and where further opportunities exist.

  >> Watch Ecommerce introduction video (playtime : 2.04 minutes)

  

  Step five : Make sure the forms on your website are easy to complete

  Form Analytics feature

  Once you get visitors through the funnel, the forms on your website are the final step to conversion and need special attention. If not done right, you could be missing out on converting a large portion of your visitors.

  Thankfully, you can now identify and fix pain points on the forms that are most important to your business’ success.

  >> Watch Form Analytics introduction video (playtime : 2.39 minutes)

  

  Step six : Discover what a customer journey looks like on a user-by-user basis and bring in key acquisition elements to your strategy

  Visitor Profiles tell you each visitors’ history

  The Profile feature summarises every visit, action and purchase made.

  Better understand :

  • Why your visitors viewed your website.
  • Why your returning visitors continue to view your website.
  • What specifically your visitors are looking for and whether they found it on your website.

  The benefit is being able to see how a combination of acquisition channels play a part in a single buyer’s journey.

  >> Watch Visitors introduction video (playtime : 1.46 minutes)

  

  To summarise

  This guide will set you on a path to creating a well-planned acquisition strategy. It’s the key to attracting and capturing the attention of potential visitors/leads, and successfully driving them through a funnel/buyer’s journey on your website.

  Because of Matomo’s reputation as a trusted analytics platform, the features above can be used to assist you in making smarter data-driven decisions. You can pursue different acquisition avenues with confidence and create a strategy that’s agile and ready for success, all while respecting user privacy.