ਇੰਸਟਾਗ੍ਰਾਮ ਦੇ ਪ੍ਰਾਈਵੇਟ API ਵਿੱਚ 9,999 ਨਜ਼ਦੀਕੀ ਦੋਸਤਾਂ ਦੀ ਸੀਮਾ ਨੂੰ ਪਾਰ ਕਰਨਾ

ਇੰਸਟਾਗ੍ਰਾਮ ਦੇ ਨਜ਼ਦੀਕੀ ਦੋਸਤਾਂ ਦੀ ਸੂਚੀ ਦੀਆਂ ਚੁਣੌਤੀਆਂ ਨਾਲ ਨਜਿੱਠਣਾ

ਕਲਪਨਾ ਕਰੋ ਕਿ ਤੁਸੀਂ ਆਪਣੀ 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	ਮੌਕ ਡੇਟਾ ਨਾਲ ਭਰੇ ਇੱਕ ਖਾਸ ਆਕਾਰ ਦੀ ਇੱਕ ਐਰੇ ਬਣਾਉਂਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ ਟੈਸਟ ਉਪਭੋਗਤਾ IDs। ਇਹ ਟੈਸਟਿੰਗ ਜਾਂ ਸਿਮੂਲੇਸ਼ਨ ਦੌਰਾਨ ਨਮੂਨਾ ਇਨਪੁੱਟ ਬਣਾਉਣ ਲਈ ਲਾਭਦਾਇਕ ਹੈ।

ਇੰਸਟਾਗ੍ਰਾਮ ਪ੍ਰਾਈਵੇਟ API ਸੀਮਾ ਦੇ ਮੁੱਦੇ ਨੂੰ ਅਸਪਸ਼ਟ ਕਰਨਾ

ਉੱਪਰ ਦਿੱਤੀਆਂ ਗਈਆਂ ਸਕ੍ਰਿਪਟਾਂ ਇੰਸਟਾਗ੍ਰਾਮ ਦੇ ਨਜ਼ਦੀਕੀ ਦੋਸਤਾਂ ਦੀ ਸੂਚੀ ਵਿੱਚ 9,999 ਤੋਂ ਵੱਧ ਉਪਭੋਗਤਾਵਾਂ ਨੂੰ ਜੋੜਨ ਦੀ ਸਮੱਸਿਆ ਨਾਲ ਨਜਿੱਠਦੀਆਂ ਹਨ, ਜੋ ਇੱਕ "ਮੈਕਸ ਬੈਸਟੀਜ਼ ਐਕਸਸੀਡਡ" ਗਲਤੀ ਨੂੰ ਸੁੱਟ ਦਿੰਦੀ ਹੈ। ਹੱਲ ਦਾ ਮੁੱਖ ਉਦੇਸ਼ ਅਨੁਯਾਈ IDs ਨੂੰ ਪ੍ਰਬੰਧਨਯੋਗ ਬੈਚਾਂ ਵਿੱਚ ਵੰਡਣਾ ਹੈ ਢੰਗ. ਹਰੇਕ ਬੈਚ ਨੂੰ ਫਿਰ API ਦੁਆਰਾ ਸੰਸਾਧਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਢੰਗ. ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਸਕ੍ਰਿਪਟ ਇੰਸਟਾਗ੍ਰਾਮ ਦੇ ਸਿਸਟਮ ਨੂੰ ਬਹੁਤ ਜ਼ਿਆਦਾ ਬੇਨਤੀ ਨਾਲ ਓਵਰਲੋਡ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਨਹੀਂ ਕਰਦੀ, 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.');
}

// 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 ਪ੍ਰਬੰਧਨ ਦੀ ਪੜਚੋਲ ਕਰਨਾ

ਜਦੋਂ ਕਿ ਇੰਸਟਾਗ੍ਰਾਮ ਦਾ API ਨਜ਼ਦੀਕੀ ਦੋਸਤਾਂ ਦੀ ਸੂਚੀ ਦੇ ਪ੍ਰਬੰਧਨ ਵਰਗੇ ਕੰਮਾਂ ਲਈ ਸਿੱਧਾ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ, "ਮੈਕਸ ਬੈਸਟੀਜ਼ ਐਕਸਸੀਡਡ" ਗਲਤੀ ਵਰਗੀਆਂ ਲੁਕੀਆਂ ਸੀਮਾਵਾਂ ਪਲੇਟਫਾਰਮ ਦੀ ਅੰਤਰੀਵ ਗੁੰਝਲਤਾ ਨੂੰ ਦਰਸਾਉਂਦੀਆਂ ਹਨ। ਇਹ ਮੁੱਦਾ ਅਕਸਰ ਗੈਰ-ਦਸਤਾਵੇਜ਼ੀ ਰੁਕਾਵਟਾਂ ਤੋਂ ਪੈਦਾ ਹੁੰਦਾ ਹੈ ਜੋ ਡਿਵੈਲਪਰਾਂ ਦਾ ਸਾਹਮਣਾ ਓਪਰੇਸ਼ਨਾਂ ਨੂੰ ਸਕੇਲਿੰਗ ਕਰਨ ਵੇਲੇ ਹੁੰਦਾ ਹੈ, ਖਾਸ ਤੌਰ 'ਤੇ ਹਜ਼ਾਰਾਂ ਅਨੁਯਾਈਆਂ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਨ ਵਾਲੇ ਉੱਚ-ਪ੍ਰੋਫਾਈਲ ਖਾਤਿਆਂ ਲਈ। ਇਹਨਾਂ ਰੁਕਾਵਟਾਂ ਦੇ ਕੁਸ਼ਲ ਪ੍ਰਬੰਧਨ ਵਿੱਚ ਕਾਰਜਾਂ ਨੂੰ ਛੋਟੇ, ਪ੍ਰਬੰਧਨਯੋਗ ਬੈਚਾਂ ਵਿੱਚ ਵੰਡਣਾ ਸ਼ਾਮਲ ਹੈ ਜਿਵੇਂ ਕਿ ਤਕਨੀਕਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਦਰ-ਸੀਮਾਬੰਦੀ ਨੂੰ ਰੋਕਣ ਲਈ ਵਿਧੀ ਅਤੇ ਦੇਰੀ ਨੂੰ ਪੇਸ਼ ਕਰਨਾ। ਇਹ ਰਣਨੀਤੀਆਂ ਆਟੋਮੇਸ਼ਨ ਟੀਚਿਆਂ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹੋਏ ਪਲੇਟਫਾਰਮ ਦੇ ਅਣ-ਬੋਲੇ ਨਿਯਮਾਂ ਦੀ ਪਾਲਣਾ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਂਦੀਆਂ ਹਨ। 💻

ਵਿਚਾਰਨ ਵਾਲਾ ਇਕ ਹੋਰ ਪਹਿਲੂ ਇਹ ਹੈ ਕਿ ਇੰਸਟਾਗ੍ਰਾਮ ਕਿਵੇਂ ਹੈਂਡਲ ਕਰਦਾ ਹੈ . ਹਾਲਾਂਕਿ ਕੁਝ ਉਪਭੋਗਤਾ ਆਪਣੇ ਨਜ਼ਦੀਕੀ ਦੋਸਤਾਂ ਦੀ ਸੂਚੀ ਵਿੱਚ 50,000 ਤੋਂ ਵੱਧ ਅਨੁਯਾਈਆਂ ਦੀ ਰਿਪੋਰਟ ਕਰਦੇ ਹਨ, API ਅਸੰਗਤ ਤੌਰ 'ਤੇ ਸੀਮਾਵਾਂ ਨੂੰ ਲਾਗੂ ਕਰਦਾ ਹੈ, ਖਾਤਿਆਂ ਦੇ ਪ੍ਰਬੰਧਨ ਦੇ ਤਰੀਕੇ ਵਿੱਚ ਭਿੰਨਤਾਵਾਂ ਦਾ ਸੁਝਾਅ ਦਿੰਦਾ ਹੈ। ਅਜਿਹੀਆਂ ਪਾਬੰਦੀਆਂ ਨੂੰ ਬਾਈਪਾਸ ਕਰਨ ਲਈ, ਡਿਵੈਲਪਰ ਗਤੀਸ਼ੀਲ ਸਕੇਲਿੰਗ ਹੱਲ ਲਾਗੂ ਕਰ ਸਕਦੇ ਹਨ। ਉਦਾਹਰਨ ਲਈ, ਗਲਤੀਆਂ ਦਾ ਸਾਹਮਣਾ ਕਰਨ 'ਤੇ ਬੈਚ ਦੇ ਆਕਾਰ ਨੂੰ ਘਟਾਉਣਾ ਜਾਂ ਵੱਡੇ ਪੈਮਾਨੇ ਦੇ ਕਾਰਜਾਂ ਲਈ ਕਈ ਪ੍ਰਮਾਣਿਤ ਸੈਸ਼ਨਾਂ ਨੂੰ ਨਿਯੁਕਤ ਕਰਨਾ ਮਦਦ ਕਰ ਸਕਦਾ ਹੈ। ਪਲੇਟਫਾਰਮ ਦੇ ਇਕਸਾਰਤਾ ਦੇ ਮਿਆਰਾਂ ਦੀ ਪਾਲਣਾ ਕਰਦੇ ਹੋਏ ਇਹ ਰਣਨੀਤੀਆਂ ਉੱਚ ਕੁਸ਼ਲਤਾ ਬਣਾਈ ਰੱਖਦੀਆਂ ਹਨ।

ਡਿਵੈਲਪਰਾਂ ਲਈ, ਮਜਬੂਤ ਗਲਤੀ ਨਾਲ ਨਜਿੱਠਣ ਨੂੰ ਤਰਜੀਹ ਦੇਣਾ ਵੀ ਜ਼ਰੂਰੀ ਹੈ। ਨਿਰੀਖਣ ਕਰਕੇ ਅਤੇ ਗਤੀਸ਼ੀਲ ਤੌਰ 'ਤੇ ਵਰਕਫਲੋ ਨੂੰ ਐਡਜਸਟ ਕਰਨਾ, ਸਕ੍ਰਿਪਟਾਂ ਬਿਨਾਂ ਕਿਸੇ ਰੁਕਾਵਟ ਦੇ ਓਪਰੇਸ਼ਨਾਂ ਦੇ ਮੁੱਦਿਆਂ ਤੋਂ ਸੁਹਾਵਣਾ ਢੰਗ ਨਾਲ ਮੁੜ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੀਆਂ ਹਨ। ਇਹ ਨਾ ਸਿਰਫ ਸਮੇਂ ਦੀ ਬਚਤ ਕਰਦਾ ਹੈ ਬਲਕਿ ਇਹ ਵੀ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਸਿਸਟਮ ਵੱਖ-ਵੱਖ ਸਥਿਤੀਆਂ ਵਿੱਚ ਕਾਰਜਸ਼ੀਲ ਰਹਿੰਦਾ ਹੈ। ਭਾਵੇਂ ਤੁਸੀਂ ਇੱਕ ਪ੍ਰਭਾਵਕ ਦੇ ਪ੍ਰਸ਼ੰਸਕ ਅਧਾਰ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰ ਰਹੇ ਹੋ ਜਾਂ ਸੋਸ਼ਲ ਮੀਡੀਆ ਮਾਰਕਿਟਰਾਂ ਲਈ ਟੂਲ ਬਣਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ, Instagram ਦੇ ਬੈਕਐਂਡ ਕੁਇਰਕਸ ਨੂੰ ਸਮਝਣਾ API ਸੀਮਾਵਾਂ ਨੂੰ ਅਨੁਕੂਲਿਤ ਹੱਲਾਂ ਦੇ ਮੌਕਿਆਂ ਵਿੱਚ ਬਦਲ ਸਕਦਾ ਹੈ। 🚀

1. "ਮੈਕਸ ਬੈਸਟੀਜ਼ ਐਕਸਸੀਡਡ" ਗਲਤੀ ਕੀ ਹੈ?
2. "ਮੈਕਸ ਬੈਸਟੀਜ਼ ਐਕਸਸੀਡਡ" ਗਲਤੀ ਉਦੋਂ ਵਾਪਰਦੀ ਹੈ ਜਦੋਂ ਇੰਸਟਾਗ੍ਰਾਮ ਦੀ ਗੈਰ-ਦਸਤਾਵੇਜ਼ੀ ਅਨੁਯਾਾਇਯਾਂ ਦੀ ਸੀਮਾ ਤੋਂ ਵੱਧ ਨੂੰ ਨਜ਼ਦੀਕੀ ਦੋਸਤਾਂ ਦੀ ਸੂਚੀ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। . ਇਹ ਆਮ ਤੌਰ 'ਤੇ 10,000-ਉਪਭੋਗਤਾ ਨਿਸ਼ਾਨ ਦੇ ਆਸਪਾਸ ਹੁੰਦਾ ਹੈ।
3. ਕੀ ਮੈਂ 9,999-ਫਾਲੋਅਰ ਸੀਮਾ ਨੂੰ ਬਾਈਪਾਸ ਕਰ ਸਕਦਾ/ਸਕਦੀ ਹਾਂ?
4. ਜਦੋਂ ਕਿ ਇੰਸਟਾਗ੍ਰਾਮ ਅਧਿਕਾਰਤ ਤੌਰ 'ਤੇ ਸੀਮਾ ਨੂੰ ਪਾਰ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਨਹੀਂ ਦਿੰਦਾ ਹੈ, ਗਤੀਸ਼ੀਲ ਬੈਚਿੰਗ ਅਤੇ ਮਲਟੀਪਲ ਸੈਸ਼ਨ ਗਲਤੀਆਂ ਨੂੰ ਟਰਿੱਗਰ ਕੀਤੇ ਬਿਨਾਂ ਵੱਡੀਆਂ ਫਾਲੋਅਰ ਸੂਚੀਆਂ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰ ਸਕਦੇ ਹਨ।
5. ਰੇਟ ਸੀਮਤ ਹੋਣ ਤੋਂ ਬਚਣ ਲਈ ਮੈਂ API ਬੇਨਤੀਆਂ ਵਿੱਚ ਦੇਰੀ ਕਿਵੇਂ ਕਰ ਸਕਦਾ ਹਾਂ?
6. ਇੱਕ ਦੇਰੀ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰੋ ਜਿਵੇਂ ਕਿ API ਕਾਲਾਂ ਵਿਚਕਾਰ ਵਿਰਾਮ ਪੇਸ਼ ਕਰਨ ਲਈ, ਬਹੁਤ ਜ਼ਿਆਦਾ ਬੇਨਤੀਆਂ ਲਈ ਫਲੈਗ ਕੀਤੇ ਜਾਣ ਦੇ ਜੋਖਮ ਨੂੰ ਘਟਾਉਂਦਾ ਹੈ।
7. ਕੀ ਇੰਸਟਾਗ੍ਰਾਮ ਦੇ ਨਜ਼ਦੀਕੀ ਦੋਸਤਾਂ ਦੀ ਸੂਚੀ API ਲਈ ਦਸਤਾਵੇਜ਼ੀ ਦਿਸ਼ਾ-ਨਿਰਦੇਸ਼ ਹਨ?
8. ਨਹੀਂ, ਇੰਸਟਾਗ੍ਰਾਮ ਇਹਨਾਂ ਸੀਮਾਵਾਂ ਨੂੰ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ ਦਸਤਾਵੇਜ਼ ਨਹੀਂ ਕਰਦਾ ਹੈ। ਡਿਵੈਲਪਰ ਅਕਸਰ ਅਜ਼ਮਾਇਸ਼, ਗਲਤੀ, ਅਤੇ ਕਮਿਊਨਿਟੀ-ਸਾਂਝੀਆਂ ਸੂਝਾਂ ਨੂੰ ਦੇਖ ਕੇ ਸਿੱਖਦੇ ਹਨ।
9. ਵੱਡੇ ਪੈਮਾਨੇ 'ਤੇ ਨਜ਼ਦੀਕੀ ਦੋਸਤਾਂ ਦੀਆਂ ਸੂਚੀਆਂ ਦੇ ਪ੍ਰਬੰਧਨ ਲਈ ਕੁਝ ਵਧੀਆ ਅਭਿਆਸ ਕੀ ਹਨ?
10. ਸਭ ਤੋਂ ਵਧੀਆ ਅਭਿਆਸਾਂ ਵਿੱਚ ਵਰਤਣਾ ਸ਼ਾਮਲ ਹੈ ਛੋਟੇ ਬੈਚਾਂ ਨੂੰ ਬਣਾਉਣ ਲਈ, ਬੈਚ ਦੇ ਆਕਾਰਾਂ ਨੂੰ ਗਤੀਸ਼ੀਲ ਤੌਰ 'ਤੇ ਵਿਵਸਥਿਤ ਕਰਨਾ, ਅਤੇ API ਸੀਮਾਵਾਂ ਦਾ ਸ਼ਾਨਦਾਰ ਢੰਗ ਨਾਲ ਜਵਾਬ ਦੇਣ ਲਈ ਮਜ਼ਬੂਤ ​​​​ਗਲਤੀ-ਪ੍ਰਬੰਧਨ ਤਰਕ ਨੂੰ ਨਿਯੁਕਤ ਕਰਨਾ।

ਇੰਸਟਾਗ੍ਰਾਮ ਦੇ ਨਜ਼ਦੀਕੀ ਦੋਸਤਾਂ ਦੀ ਸੂਚੀ ਨੂੰ ਕੁਸ਼ਲਤਾ ਨਾਲ ਪ੍ਰਬੰਧਨ ਲਈ ਨਵੀਨਤਾਕਾਰੀ ਹੱਲਾਂ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ ਜਦੋਂ ਗੈਰ-ਦਸਤਾਵੇਜ਼ੀ API ਰੁਕਾਵਟਾਂ ਦਾ ਸਾਹਮਣਾ ਕਰਨਾ ਪੈਂਦਾ ਹੈ। "ਮੈਕਸ ਬੈਸਟੀਜ਼ ਐਕਸਸੀਡਡ" ਗਲਤੀ ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਆਟੋਮੇਸ਼ਨ ਰਣਨੀਤੀਆਂ 'ਤੇ ਮੁੜ ਵਿਚਾਰ ਕਰਨ ਅਤੇ ਸੀਮਾਵਾਂ ਦੇ ਅੰਦਰ ਰਹਿਣ ਲਈ ਬੈਚਿੰਗ ਵਰਗੇ ਅਨੁਕੂਲਿਤ ਸਾਧਨਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ ਚੁਣੌਤੀ ਦਿੰਦੀ ਹੈ। ਇਹ ਅਭਿਆਸ ਮਾਪਯੋਗਤਾ ਨੂੰ ਵਧਾਉਂਦੇ ਹਨ ਅਤੇ ਜੋਖਮ ਨੂੰ ਘਟਾਉਂਦੇ ਹਨ। 💡

ਇੱਕ ਵਿਚਾਰਸ਼ੀਲ ਪਹੁੰਚ ਨਾਲ, ਇਹ ਮੁੱਦਾ ਇੱਕ ਰੁਕਾਵਟ ਤੋਂ ਆਟੋਮੇਸ਼ਨ ਤਕਨੀਕਾਂ ਨੂੰ ਸੁਧਾਰਨ ਦੇ ਮੌਕੇ ਵਿੱਚ ਬਦਲ ਜਾਂਦਾ ਹੈ। ਇੰਸਟਾਗ੍ਰਾਮ ਦੇ ਬੈਕਐਂਡ ਕੁਇਰਕਸ ਨੂੰ ਸਮਝਣਾ ਅਤੇ ਮਜ਼ਬੂਤ ​​​​ਐਰਰ ਹੈਂਡਲਿੰਗ ਦਾ ਲਾਭ ਲੈਣਾ ਇੱਕ ਸਹਿਜ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ। ਵਿਆਪਕ ਉਪਭੋਗਤਾ ਅਧਾਰਾਂ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਨ ਵਾਲੇ ਡਿਵੈਲਪਰਾਂ ਲਈ, ਇਹ ਪਾਠ ਭਰੋਸੇਯੋਗ, ਉੱਚ-ਪ੍ਰਦਰਸ਼ਨ ਵਾਲੀਆਂ ਸਕ੍ਰਿਪਟਾਂ ਬਣਾਉਣ ਲਈ ਅਨਮੋਲ ਹਨ। 🚀