Instagram ના ખાનગી API માં 9,999

Louis Robert

સોમવાર, 16 ડિસેમ્બર, 2024 એ 03:23:48 PM વાગ્યે

ઇન્સ્ટાગ્રામની નજીકના મિત્રોની સૂચિની પડકારોનો સામનો કરવો

કલ્પના કરો કે તમે તમારા Instagram નજીકના મિત્રોની સૂચિમાં અનુયાયીઓને ઉમેરવાનું સ્વચાલિત કરવા માટે એક સાધન બનાવ્યું છે, અને જ્યાં સુધી તમે આશ્ચર્યજનક સ્નેગ ન કરો ત્યાં સુધી બધું સરળતાથી ચાલે છે. અચાનક, 9,999-અનુયાયી ચિહ્ન પર, તમારી સારી રીતે તેલયુક્ત સ્ક્રિપ્ટ ક્રિપ્ટિક "મેક્સ બેસ્ટીઝ ઓળંગી" ભૂલ સાથે અટકી જાય છે. 🙃 મારા જેવા વિકાસકર્તા માટે, આ એક અણધારી અવરોધ હતો.

આ પ્રોજેક્ટનો હેતુ પ્રભાવકોને અનુયાયીઓની વિશાળ સૂચિનું સંચાલન કરવામાં મદદ કરવા માટે હતો જેઓ Instagram ના ક્લોઝ ફ્રેન્ડ્સ સુવિધા દ્વારા વિશિષ્ટ સામગ્રી મેળવે છે. કોઈ દસ્તાવેજી મર્યાદા વિના, મેં વિચાર્યું કે મારો કોડ કોઈપણ સ્કેલને હેન્ડલ કરી શકે છે, પરંતુ વાસ્તવિકતા અન્યથા કહે છે. આ ભૂલ ઝડપથી એક રહસ્યમાં ફેરવાઈ ગઈ જેને મારે ઉકેલવાની જરૂર હતી.

શરૂઆતમાં, મેં ધાર્યું કે તે મારા અમલીકરણમાં બગ છે અથવા કદાચ બેચ કદ અથવા API વિનંતી દરો સાથેની સમસ્યા છે. જો કે, બહુવિધ અભિગમોનું પરીક્ષણ કર્યા પછી, 10,000મા અનુયાયી ઉમેરાતાની સાથે જ સમસ્યા યથાવત રહી. શું થઈ રહ્યું હતું તે જાણવા અને ઉકેલ શોધવા માટે મારે ઊંડા ઉતરવું પડ્યું.

પછી ભલે તમે વર્કફ્લોને સ્વચાલિત કરતા ડેવલપર હોવ અથવા સામાજિક મીડિયા API ને સ્કેલ પર હેન્ડલ કરવા વિશે કોઈ ઉત્સુક હોવ, આ વાર્તા આવી તકનીકી અવરોધોને દૂર કરવા પર પ્રકાશ પાડે છે. અને સારી ડીબગીંગ ચેલેન્જ કોને પસંદ નથી? 🛠️

આદેશ	ઉપયોગનું ઉદાહરણ
ig.friendship.setBesties	આ Instagram ખાનગી API પદ્ધતિ નજીકના મિત્રોની સૂચિમાંથી વપરાશકર્તાઓને ઉમેરવા અને દૂર કરવાની મંજૂરી આપે છે. તે ખાસ કરીને "બેસ્ટીઝ" મેનેજમેન્ટને લક્ષ્ય બનાવે છે અને મર્યાદા ઓળંગવાની સમસ્યાને નિયંત્રિત કરવા માટે કેન્દ્રિય છે.
Array.prototype.slice	અનુયાયીઓની મૂળ સૂચિમાંથી નાના એરે (બેચ) બનાવવા માટે વપરાય છે. આ સુનિશ્ચિત કરે છે કે API વિનંતિઓ એક સમયે મર્યાદિત સંખ્યામાં વપરાશકર્તાઓને હેન્ડલ કરે છે જેથી સિસ્ટમને વધુ પડતું ન આવે.
await new Promise(resolve =>await new Promise(resolve => setTimeout(resolve, delay))	API કૉલ્સ વચ્ચે વિલંબનો પરિચય આપે છે. સળંગ વિનંતીઓ કરતી વખતે દર-મર્યાદિત મુદ્દાઓને ટાળવા અથવા Instagram API દ્વારા થ્રોટલિંગ માટે આ મહત્વપૂર્ણ છે.
Math.floor	એરર હેન્ડલિંગ દરમિયાન બેચના કદને અડધું કરીને ગતિશીલ રીતે ગોઠવવા માટે વપરાય છે. આ બેચ પ્રોસેસિંગ પર વધુ સારું નિયંત્રણ સુનિશ્ચિત કરે છે અને API અવરોધોને સ્વીકારવામાં મદદ કરે છે.
jest.spyOn	એકમ પરીક્ષણો દરમિયાન API ક્લાયંટની વિશિષ્ટ પદ્ધતિઓનો ઉપહાસ કરવા માટે ઉપયોગમાં લેવાતી જેસ્ટ પરીક્ષણ ઉપયોગિતા. આ સુનિશ્ચિત કરે છે કે ટેસ્ટ એક્ઝિક્યુશન દરમિયાન કોઈ વાસ્તવિક API કૉલ્સ કરવામાં આવતાં નથી, પરીક્ષણ સલામતી અને ઝડપમાં સુધારો કરે છે.
response.status	API પ્રતિસાદમાંથી HTTP સ્થિતિ કોડને બહાર કાઢે છે. તે ચોક્કસ ભૂલોને ઓળખવા માટે જરૂરી છે, જેમ કે "400 ખરાબ વિનંતી," અને યોગ્ય ભૂલ-હેન્ડલિંગ વ્યૂહરચનાઓ લાગુ કરવા.
response.body.message.includes	API પ્રતિસાદ બોડીમાં ચોક્કસ ભૂલ સંદેશાઓ માટે તપાસ કરે છે. આનાથી "મેક્સ બેસ્ટીઝ ઓળંગાઈ" જેવી ભૂલોની ચોક્કસ ઓળખ માટે પરવાનગી આપે છે અને લક્ષિત હેન્ડલિંગની સુવિધા આપે છે.
jest.spyOn(...).mockResolvedValue	એકમ પરીક્ષણોમાં સફળ API પ્રતિસાદોનું અનુકરણ કરે છે. આ સુનિશ્ચિત કરે છે કે લાઇવ API એક્સેસની જરૂર વગર સામાન્ય સ્થિતિમાં કોડનું પરીક્ષણ કરી શકાય છે.
jest.spyOn(...).mockImplementationOnce	પરીક્ષણ દરમિયાન ભૂલ પ્રતિભાવના એક જ ઉદાહરણનું અનુકરણ કરે છે. આ કોડ ચોક્કસ API નિષ્ફળતાઓને કેવી રીતે હેન્ડલ કરે છે તે ચકાસવામાં મદદ કરે છે, જેમ કે દર મર્યાદા અથવા મહત્તમ ક્ષમતા.
Array.prototype.fill	મૉક ડેટાથી ભરેલા ચોક્કસ કદની એરે બનાવે છે, જેમ કે પરીક્ષણ વપરાશકર્તા ID. આ પરીક્ષણ અથવા સિમ્યુલેશન દરમિયાન નમૂના ઇનપુટ્સ બનાવવા માટે ઉપયોગી છે.

ઇન્સ્ટાગ્રામ પ્રાઇવેટ API મર્યાદાના મુદ્દાને અસ્પષ્ટ બનાવવું

ઉપરોક્ત આપવામાં આવેલી સ્ક્રિપ્ટ્સ Instagram ના ક્લોઝ ફ્રેન્ડ્સ લિસ્ટમાં 9,999 કરતાં વધુ વપરાશકર્તાઓને ઉમેરવાની સમસ્યાને હલ કરે છે, જે "મેક્સ બેસ્ટીઝ ઓળંગી" ભૂલ ફેંકે છે. ઉકેલનો મુખ્ય આધાર અનુયાયી ID ને વ્યવસ્થાપન કરી શકાય તેવા બેચેસ માં વિભાજિત કરવાનો છે સ્લાઇસ પદ્ધતિ દરેક બેચ પછી API દ્વારા પ્રક્રિયા કરવામાં આવે છે સેટબેસ્ટીઝ પદ્ધતિ આ સુનિશ્ચિત કરે છે કે સ્ક્રિપ્ટ વધુ પડતી મોટી વિનંતી સાથે Instagram ની સિસ્ટમને ઓવરલોડ કરવાનો પ્રયાસ કરતી નથી, API દર મર્યાદાને ટ્રિગર કરવાનું જોખમ ઘટાડે છે.

આ સ્ક્રિપ્ટોની વિશિષ્ટ વિશેષતાઓમાંની એક API વિનંતીઓ વચ્ચે વિલંબનો ઉપયોગ છે. સમાવિષ્ટ કરીને એ સેટ ટાઈમઆઉટ ફંક્શન, સ્ક્રિપ્ટ ખાતરી કરે છે કે દરેક બેચ વચ્ચે પૂરતો સમય છે, Instagram ને પ્રવૃત્તિને સ્પામી અથવા અપમાનજનક તરીકે ઓળખવાથી અટકાવે છે. ઉદાહરણ તરીકે, જો તમે ક્યારેય તમારું એકાઉન્ટ "શંકાસ્પદ પ્રવૃત્તિ" માટે અસ્થાયી રૂપે લૉક કર્યું હોય, તો આ વિલંબ પદ્ધતિ આવા પરિણામો સામે રક્ષણ તરીકે કાર્ય કરે છે. ⏱️

ડાયનેમિક એરર હેન્ડલિંગ એ અન્ય મહત્વપૂર્ણ ઘટક છે. સ્ક્રિપ્ટ ચોક્કસ એરર કોડ અથવા API દ્વારા પરત કરવામાં આવેલા સંદેશાઓને શોધી કાઢે છે, જેમ કે "400 ખરાબ વિનંતી" અથવા "મહત્તમ શ્રેષ્ઠીઓ ઓળંગાઈ ગઈ છે." જો આવી ભૂલ થાય, તો સ્ક્રિપ્ટ કાં તો બેચનું કદ ઘટાડે છે અથવા સંપૂર્ણ રીતે પ્રક્રિયા કરવાનું બંધ કરે છે. આ પ્રકારનું અનુકૂલનશીલ તર્ક સુનિશ્ચિત કરે છે કે પ્રોગ્રામ કાર્યક્ષમ રહે છે અને બિનજરૂરી પુનઃપ્રયાસોને અટકાવે છે જે એકાઉન્ટ પર પ્રતિબંધ લાવી શકે છે.

છેલ્લે, પરીક્ષણ એ ઉકેલનો આવશ્યક ભાગ છે. એકમ પરીક્ષણો વિવિધ દૃશ્યોનું અનુકરણ કરે છે, જેમાં સફળ API કૉલ્સ અને ભૂલના કેસોનો સમાવેશ થાય છે, મોક કરેલા ડેટાનો ઉપયોગ કરીને. આ અભિગમ સુનિશ્ચિત કરે છે કે સ્ક્રિપ્ટ મજબૂત છે અને વિવિધ પરિસ્થિતિઓમાં યોગ્ય રીતે કાર્ય કરે છે. તમે ચાહકોની વધતી જતી સૂચિનું સંચાલન કરતા પ્રભાવક હોવ અથવા ક્લાયન્ટ્સ માટે વર્કફ્લોને સ્વચાલિત કરતા ડેવલપર હોવ, આ સ્ક્રિપ્ટ્સ Instagram ની છુપાયેલી મર્યાદાઓને હેન્ડલ કરવા માટે સ્કેલેબલ અને સુરક્ષિત રીત પ્રદાન કરે છે. 🚀

મોડ્યુલર બેકએન્ડ સોલ્યુશન્સ સાથે "મેક્સ બેસ્ટીઝ ઓળંગી" ભૂલને ઉકેલવી

આ સોલ્યુશન બેચેસ બનાવીને અને અસરકારક રીતે મર્યાદાઓનું સંચાલન કરીને "મેક્સ બેસ્ટીઝ ઓળંગી" સમસ્યાને હેન્ડલ કરવા માટે ટાઇપસ્ક્રીપ્ટમાં મોડ્યુલર બેકએન્ડ અભિગમ દર્શાવે છે.

// Import required modules
import { IgApiClient } from 'instagram-private-api';

// Define a function to check and handle the limit dynamically
async function manageCloseFriendsLimit(ig: IgApiClient, followerIds: string[], batchSize: number, delay: number): Promise<void> {
    let totalAdded = 0;
    console.log(\`Processing \${followerIds.length} followers...\`);

    for (let i = 0; i < followerIds.length; i += batchSize) {
        const batch = followerIds.slice(i, i + batchSize);
        try {
            await ig.friendship.setBesties({ add: batch, remove: [] });
            totalAdded += batch.length;
            console.log(\`Batch added. Total followers added: \${totalAdded}\`);
        } catch (error) {
            if (error.response && error.response.status === 400 && error.response.body.message.includes('max besties exceeded')) {
                console.error('Instagram has capped the close friends limit.');
                break;
            } else {
                console.error('An unexpected error occurred:', error);
            }
        }

        await new Promise(resolve => setTimeout(resolve, delay));
    }

    console.log('Processing complete.');
}

TypeScript માં બેચ સાઇઝ એડજસ્ટમેન્ટ સાથે API મર્યાદાઓનું સંચાલન કરવું

આ સ્ક્રિપ્ટ ઇન્સ્ટાગ્રામની બિનદસ્તાવેજીકૃત મર્યાદાઓને ફટકારવાનું ટાળવા માટે ગતિશીલ બેચ કદના ગોઠવણોનો અમલ કરે છે.

// Import required modules
import { IgApiClient } from 'instagram-private-api';

// Function to add close friends with batch size adaptation
async function dynamicBatchHandler(ig: IgApiClient, followerIds: string[], maxBatchSize: number, delay: number): Promise<void> {
    let batchSize = maxBatchSize;

    for (let i = 0; i < followerIds.length;) {
        const batch = followerIds.slice(i, i + batchSize);
        try {
            await ig.friendship.setBesties({ add: batch, remove: [] });
            console.log(\`Added batch of size \${batch.length}\`);
            i += batch.length;
        } catch (error) {
            if (batchSize > 1) {
                console.warn('Reducing batch size due to error...');
                batchSize = Math.floor(batchSize / 2);
            } else {
                console.error('Minimum batch size reached. Stopping process.');
                break;
            }
        }

        await new Promise(resolve => setTimeout(resolve, delay));
    }
}

ઉપરોક્ત ઉકેલો માટે એકમ પરીક્ષણો

ઉપરોક્ત સ્ક્રિપ્ટોની કાર્યક્ષમતાને માન્ય કરવા માટે અહીં એક જેસ્ટ ટેસ્ટ સ્યુટ છે.

// Import necessary modules
import { manageCloseFriendsLimit, dynamicBatchHandler } from './closeFriendsHandler';
import { IgApiClient } from 'instagram-private-api';

describe('Close Friends Manager', () => {
    let igMock: IgApiClient;

    beforeEach(() => {
        igMock = new IgApiClient();
        jest.spyOn(igMock.friendship, 'setBesties').mockResolvedValue(true);
    });

    test('manageCloseFriendsLimit processes all followers', async () => {
        const followers = Array(100).fill('user_id');
        await expect(manageCloseFriendsLimit(igMock, followers, 10, 100)).resolves.toBeUndefined();
    });

    test('dynamicBatchHandler adjusts batch size on error', async () => {
        jest.spyOn(igMock.friendship, 'setBesties').mockImplementationOnce(() => {
            throw new Error('API Limit');
        });

        const followers = Array(50).fill('user_id');
        await expect(dynamicBatchHandler(igMock, followers, 10, 100)).resolves.toBeUndefined();
    });
});

Instagram ની છુપાયેલી મર્યાદાઓ અને કાર્યક્ષમ API મેનેજમેન્ટનું અન્વેષણ કરવું

જ્યારે Instagram નું API નજીકના મિત્રોની સૂચિનું સંચાલન કરવા જેવા કાર્યો માટે સરળ દેખાય છે, ત્યારે છુપાયેલી મર્યાદાઓ જેવી કે "મેક્સ બેસ્ટીઝ ઓળંગી" ભૂલ પ્લેટફોર્મની અંતર્ગત જટિલતાને છતી કરે છે. આ સમસ્યા ઘણીવાર બિનદસ્તાવેજીકૃત અવરોધોમાંથી ઉદ્ભવે છે જે વિકાસકર્તાઓને કામગીરીને સ્કેલિંગ કરતી વખતે આવે છે, ખાસ કરીને હજારો અનુયાયીઓનું સંચાલન કરતા હાઇ-પ્રોફાઇલ એકાઉન્ટ્સ માટે. આ અવરોધોના કાર્યક્ષમ સંચાલનમાં ટેકનિકનો ઉપયોગ કરીને કાર્યોને નાના, વ્યવસ્થિત બેચમાં વિભાજીત કરવાનો સમાવેશ થાય છે. સ્લાઇસ દર-મર્યાદાને રોકવા માટે પદ્ધતિ અને વિલંબનો પરિચય. આ વ્યૂહરચનાઓ ઓટોમેશન લક્ષ્યો હાંસલ કરતી વખતે પ્લેટફોર્મના અસ્પષ્ટ નિયમોનું પાલન સુનિશ્ચિત કરે છે. 💻

ધ્યાનમાં લેવાનું બીજું પાસું એ છે કે Instagram કેવી રીતે હેન્ડલ કરે છે બેકએન્ડ માન્યતા. કેટલાક વપરાશકર્તાઓ તેમના નજીકના મિત્રોની સૂચિમાં 50,000 થી વધુ અનુયાયીઓ હોવાનો અહેવાલ આપે છે, તેમ છતાં, API અસંગત રીતે મર્યાદાઓને લાગુ કરે છે, જે એકાઉન્ટ્સ કેવી રીતે સંચાલિત થાય છે તેમાં વિવિધતા સૂચવે છે. આવા પ્રતિબંધોને બાયપાસ કરવા માટે, વિકાસકર્તાઓ ગતિશીલ સ્કેલિંગ સોલ્યુશન્સનો અમલ કરી શકે છે. ઉદાહરણ તરીકે, ભૂલોનો સામનો કરવા પર બેચના કદને ઘટાડવા અથવા મોટા પાયે કામગીરી માટે બહુવિધ પ્રમાણિત સત્રોનો ઉપયોગ મદદ કરી શકે છે. આ વ્યૂહરચનાઓ પ્લેટફોર્મના અખંડિતતા ધોરણોનું પાલન કરતી વખતે ઉચ્ચ કાર્યક્ષમતા જાળવી રાખે છે.

વિકાસકર્તાઓ માટે, મજબૂત એરર હેન્ડલિંગને પ્રાથમિકતા આપવી પણ જરૂરી છે. નિરીક્ષણ કરીને ભૂલ જવાબો અને વર્કફ્લોને ગતિશીલ રીતે સમાયોજિત કરીને, સ્ક્રિપ્ટો કામગીરીમાં વિક્ષેપ પાડ્યા વિના સમસ્યાઓમાંથી આકર્ષક રીતે પુનઃપ્રાપ્ત કરી શકે છે. આનાથી માત્ર સમયની જ બચત થતી નથી પરંતુ તે સુનિશ્ચિત પણ કરે છે કે સિસ્ટમ વિવિધ પરિસ્થિતિઓમાં કાર્યરત રહે છે. ભલે તમે પ્રભાવકના ચાહક આધારનું સંચાલન કરી રહ્યાં હોવ અથવા સોશિયલ મીડિયા માર્કેટર્સ માટે સાધનો બનાવતા હોવ, Instagram ના બેકએન્ડ ક્વિર્ક્સને સમજવાથી API મર્યાદાઓને ઑપ્ટિમાઇઝ સોલ્યુશન્સ માટેની તકોમાં ફેરવી શકે છે. 🚀

Instagram API અને ક્લોઝ ફ્રેન્ડ લિસ્ટ મેનેજમેન્ટ વિશે સામાન્ય પ્રશ્નો

"મેક્સ બેસ્ટીઝ ઓળંગી" ભૂલ શું છે?
"મેક્સ બેસ્ટીઝ ઓળંગી" ભૂલ ત્યારે થાય છે જ્યારે ઇન્સ્ટાગ્રામના અનુયાયીઓની બિનદસ્તાવેજીકૃત મર્યાદા કરતાં વધુનો ઉપયોગ કરીને નજીકના મિત્રોની સૂચિમાં ઉમેરવાનો પ્રયાસ કરવામાં આવે છે. ig.friendship.setBesties. આ સામાન્ય રીતે 10,000-યુઝર માર્કની આસપાસ થાય છે.
શું હું 9,999-અનુયાયી મર્યાદાને બાયપાસ કરી શકું?
જ્યારે Instagram સત્તાવાર રીતે મર્યાદાને ઓળંગવાની મંજૂરી આપતું નથી, ગતિશીલ બેચિંગ અને બહુવિધ સત્રો ભૂલોને ટ્રિગર કર્યા વિના અસરકારક રીતે મોટી અનુયાયી સૂચિનું સંચાલન કરવામાં મદદ કરી શકે છે.
દર મર્યાદા ટાળવા માટે હું API વિનંતીઓને કેવી રીતે વિલંબિત કરી શકું?
જેવી વિલંબ પદ્ધતિનો ઉપયોગ કરો await new Promise(resolve => setTimeout(resolve, delay)) API કૉલ્સ વચ્ચે વિરામ રજૂ કરવા માટે, વધુ પડતી વિનંતીઓ માટે ફ્લેગ થવાનું જોખમ ઘટાડવું.
શું Instagram ના ક્લોઝ ફ્રેન્ડ્સ લિસ્ટ API માટે દસ્તાવેજી માર્ગદર્શિકા છે?
ના, Instagram આ મર્યાદાઓને સ્પષ્ટપણે દસ્તાવેજ કરતું નથી. વિકાસકર્તાઓ ઘણીવાર અજમાયશ, ભૂલ અને સમુદાય દ્વારા વહેંચાયેલ આંતરદૃષ્ટિનું નિરીક્ષણ કરીને શીખે છે.
મોટા પાયે નજીકના મિત્રોની સૂચિનું સંચાલન કરવા માટે કેટલીક શ્રેષ્ઠ પદ્ધતિઓ શું છે?
શ્રેષ્ઠ પ્રયાસોમાં ઉપયોગનો સમાવેશ થાય છે slice નાના બેચ બનાવવા, ગતિશીલ રીતે બેચના કદને સમાયોજિત કરવા, અને API અવરોધોને આકર્ષક રીતે પ્રતિસાદ આપવા માટે મજબૂત ભૂલ-હેન્ડલિંગ તર્કનો ઉપયોગ કરવો.

Instagram API મર્યાદાઓમાંથી મુખ્ય ટેકવેઝ

જ્યારે બિનદસ્તાવેજીકૃત API અવરોધોનો સામનો કરવો પડે ત્યારે Instagram ની નજીકના મિત્રોની સૂચિને અસરકારક રીતે સંચાલિત કરવા માટે નવીન ઉકેલોની જરૂર પડે છે. "મેક્સ બેસ્ટીઝ ઓળંગી" ભૂલ વિકાસકર્તાઓને ઓટોમેશન વ્યૂહરચનાઓ પર પુનર્વિચાર કરવા અને મર્યાદામાં રહેવા માટે બેચિંગ જેવા અનુકૂલનશીલ સાધનોનો અમલ કરવા પડકાર આપે છે. આ પદ્ધતિઓ માપનીયતા વધારે છે અને જોખમ ઘટાડે છે. 💡

વિચારશીલ અભિગમ સાથે, આ મુદ્દો રોડ બ્લોકમાંથી ઓટોમેશન તકનીકોને રિફાઇન કરવાની તકમાં પરિવર્તિત થાય છે. ઇન્સ્ટાગ્રામના બેકએન્ડ ક્વિક્સને સમજવું અને મજબૂત એરર હેન્ડલિંગનો લાભ લેવો એ સીમલેસ પ્રક્રિયાને સુનિશ્ચિત કરે છે. વ્યાપક વપરાશકર્તા પાયાનું સંચાલન કરતા વિકાસકર્તાઓ માટે, આ પાઠ વિશ્વસનીય, ઉચ્ચ-પ્રદર્શન સ્ક્રિપ્ટો બનાવવા માટે અમૂલ્ય છે. 🚀

Instagram ખાનગી API આંતરદૃષ્ટિ માટે સ્ત્રોતો અને સંદર્ભો

આ લેખની સામગ્રીના દસ્તાવેજીકરણ અને ઉપયોગની આંતરદૃષ્ટિ પર આધારિત છે Instagram ખાનગી API GitHub રીપોઝીટરી .
પરની ચર્ચાઓમાંથી વધારાના સંશોધન અને મુશ્કેલીનિવારણ ટિપ્સ મેળવવામાં આવી હતી સ્ટેક ઓવરફ્લો ડેવલપર ફોરમ .
વાસ્તવિક-વિશ્વના ઉદાહરણો અને સમુદાય પ્રતિસાદનો સંદર્ભ આપવામાં આવ્યો હતો Reddit નું Instagram API Subreddit .

Instagram ના ખાનગી API માં 9,999 નજીકના મિત્રોની મર્યાદાને વટાવી