iploop 1.0.0

package/README.md

@@ -0,0 +1,76 @@
+# IPLoop Node.js SDK
+
+Residential proxy SDK — route requests through millions of real devices across 111+ countries.
+
+## Install
+
+```bash
+npm install iploop
+```
+
+## Quick Start
+
+```javascript
+const IPLoop = require('iploop');
+
+const ip = new IPLoop('your-api-key');
+
+// Fetch any URL through a residential proxy
+const res = await ip.get('https://httpbin.org/ip');
+console.log(res.body);
+
+// Target a specific country
+const de = await ip.get('https://example.com', { country: 'DE' });
+
+// POST request
+const post = await ip.post('https://api.example.com/data', {
+  body: JSON.stringify({ key: 'value' }),
+  headers: { 'Content-Type': 'application/json' }
+});
+```
+
+## Sticky Sessions
+
+Keep the same IP across multiple requests:
+
+```javascript
+const session = ip.session({ country: 'US', city: 'newyork' });
+const page1 = await session.get('https://site.com/page1'); // same IP
+const page2 = await session.get('https://site.com/page2'); // same IP
+```
+
+## Geo-Targeting
+
+```javascript
+const ip = new IPLoop('key', { country: 'JP' }); // All requests through Japan
+// Or per-request:
+const res = await ip.get('https://example.com', { country: 'GB' });
+```
+
+## TypeScript
+
+Full TypeScript support included:
+
+```typescript
+import IPLoop from 'iploop';
+const ip = new IPLoop('your-api-key', { country: 'US' });
+```
+
+## API
+
+- `ip.get(url, options?)` — GET request
+- `ip.post(url, options?)` — POST request  
+- `ip.put(url, options?)` — PUT request
+- `ip.delete(url, options?)` — DELETE request
+- `ip.fetch(url, options?)` — Custom request
+- `ip.session(options?)` — Create sticky session
+- `ip.countries()` — List available countries
+
+## Links
+
+- Website: [iploop.io](https://iploop.io)
+- Twitter: [@iploop_io](https://x.com/iploop_io)
+
+## License
+
+MIT

package/index.d.ts

@@ -0,0 +1,51 @@
+declare class IPLoop {
+  constructor(apiKey: string, options?: {
+    gateway?: string;
+    port?: number;
+    country?: string;
+    city?: string;
+    timeout?: number;
+  });
+
+  fetch(url: string, options?: RequestOptions): Promise<IPLoopResponse>;
+  get(url: string, options?: RequestOptions): Promise<IPLoopResponse>;
+  post(url: string, options?: RequestOptions): Promise<IPLoopResponse>;
+  put(url: string, options?: RequestOptions): Promise<IPLoopResponse>;
+  delete(url: string, options?: RequestOptions): Promise<IPLoopResponse>;
+  session(options?: SessionOptions): IPLoopSession;
+  countries(): Promise<string[]>;
+}
+
+interface RequestOptions {
+  method?: string;
+  headers?: Record<string, string>;
+  body?: string | object;
+  country?: string;
+  city?: string;
+  session?: string;
+  timeout?: number;
+}
+
+interface SessionOptions {
+  country?: string;
+  city?: string;
+  session?: string;
+}
+
+interface IPLoopResponse {
+  status: number;
+  statusCode: number;
+  headers: Record<string, string>;
+  body: string;
+  text(): Promise<string>;
+  json(): Promise<any>;
+}
+
+declare class IPLoopSession {
+  fetch(url: string, options?: RequestOptions): Promise<IPLoopResponse>;
+  get(url: string, options?: RequestOptions): Promise<IPLoopResponse>;
+  post(url: string, options?: RequestOptions): Promise<IPLoopResponse>;
+}
+
+export = IPLoop;
+export { IPLoop, IPLoopSession, RequestOptions, SessionOptions, IPLoopResponse };

package/index.js

@@ -0,0 +1,152 @@
+const http = require('http');
+const https = require('https');
+const { URL } = require('url');
+
+class IPLoop {
+  constructor(apiKey, options = {}) {
+    this.apiKey = apiKey;
+    this.gateway = options.gateway || 'gateway.iploop.io';
+    this.port = options.port || 8880;
+    this.country = options.country || null;
+    this.city = options.city || null;
+    this.timeout = options.timeout || 30000;
+  }
+
+  _buildAuth(options = {}) {
+    const parts = [this.apiKey];
+    const country = options.country || this.country;
+    const city = options.city || this.city;
+    const session = options.session || null;
+    
+    if (country) parts.push(`country-${country}`);
+    if (city) parts.push(`city-${city}`);
+    if (session) parts.push(`session-${session}`);
+    
+    return `user:${parts.join('-')}`;
+  }
+
+  fetch(url, options = {}) {
+    return new Promise((resolve, reject) => {
+      const target = new URL(url);
+      const auth = this._buildAuth(options);
+      
+      const proxyOptions = {
+        hostname: this.gateway,
+        port: this.port,
+        path: url,
+        method: options.method || 'GET',
+        headers: {
+          ...this._defaultHeaders(target, options),
+          ...(options.headers || {}),
+          'Proxy-Authorization': 'Basic ' + Buffer.from(auth).toString('base64'),
+          'Host': target.hostname,
+        },
+        timeout: options.timeout || this.timeout,
+      };
+
+      const req = http.request(proxyOptions, (res) => {
+        let data = '';
+        res.on('data', chunk => data += chunk);
+        res.on('end', () => {
+          resolve({
+            status: res.statusCode,
+            statusCode: res.statusCode,
+            headers: res.headers,
+            text: () => Promise.resolve(data),
+            json: () => Promise.resolve(JSON.parse(data)),
+            body: data,
+          });
+        });
+      });
+
+      req.on('error', reject);
+      req.on('timeout', () => {
+        req.destroy();
+        reject(new Error('Request timeout'));
+      });
+
+      if (options.body) {
+        req.write(typeof options.body === 'string' ? options.body : JSON.stringify(options.body));
+      }
+      req.end();
+    });
+  }
+
+  get(url, options = {}) {
+    return this.fetch(url, { ...options, method: 'GET' });
+  }
+
+  post(url, options = {}) {
+    return this.fetch(url, { ...options, method: 'POST' });
+  }
+
+  put(url, options = {}) {
+    return this.fetch(url, { ...options, method: 'PUT' });
+  }
+
+  delete(url, options = {}) {
+    return this.fetch(url, { ...options, method: 'DELETE' });
+  }
+
+  session(options = {}) {
+    const sessionId = options.session || `sess-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    return new IPLoopSession(this, { ...options, session: sessionId });
+  }
+
+  _defaultHeaders(target, options = {}) {
+    const country = options.country || this.country || 'US';
+    const langs = {
+      US: 'en-US,en;q=0.9',
+      GB: 'en-GB,en;q=0.9',
+      DE: 'de-DE,de;q=0.9,en;q=0.8',
+      FR: 'fr-FR,fr;q=0.9,en;q=0.8',
+      JP: 'ja-JP,ja;q=0.9,en;q=0.8',
+      BR: 'pt-BR,pt;q=0.9,en;q=0.8',
+      IL: 'he-IL,he;q=0.9,en;q=0.8',
+    };
+
+    return {
+      'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36',
+      'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+      'Accept-Language': langs[country] || langs.US,
+      'Accept-Encoding': 'gzip, deflate, br',
+      'Cache-Control': 'no-cache',
+      'Sec-Fetch-Dest': 'document',
+      'Sec-Fetch-Mode': 'navigate',
+      'Sec-Fetch-Site': 'none',
+      'Sec-Ch-Ua': '"Chromium";v="122", "Not(A:Brand";v="24"',
+      'Sec-Ch-Ua-Mobile': '?0',
+      'Sec-Ch-Ua-Platform': '"Windows"',
+      'Upgrade-Insecure-Requests': '1',
+    };
+  }
+
+  async countries() {
+    return ['US', 'GB', 'DE', 'FR', 'JP', 'BR', 'IN', 'AU', 'CA', 'IL', 
+            'KR', 'SG', 'NL', 'SE', 'CH', 'ES', 'IT', 'PL', 'TR', 'ZA',
+            'NG', 'PH', 'MX', 'AR', 'CL', 'CO', 'EG', 'KE', 'TH', 'VN'];
+  }
+}
+
+class IPLoopSession {
+  constructor(client, options) {
+    this.client = client;
+    this.options = options;
+  }
+
+  fetch(url, options = {}) {
+    return this.client.fetch(url, { ...this.options, ...options });
+  }
+
+  get(url, options = {}) {
+    return this.fetch(url, { ...options, method: 'GET' });
+  }
+
+  post(url, options = {}) {
+    return this.fetch(url, { ...options, method: 'POST' });
+  }
+}
+
+module.exports = IPLoop;
+module.exports.IPLoop = IPLoop;
+module.exports.default = IPLoop;

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "iploop",
+  "version": "1.0.0",
+  "description": "IPLoop Residential Proxy SDK — route requests through millions of real devices",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "keywords": ["proxy", "residential-proxy", "web-scraping", "rotating-proxy", "socks5", "http-proxy", "iploop", "sdk"],
+  "author": "IPLoop <partners@iploop.io>",
+  "license": "MIT",
+  "homepage": "https://iploop.io",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/iploop/iploop-node"
+  },
+  "engines": {
+    "node": ">=14"
+  },
+  "dependencies": {
+    "node-fetch": "^2.7.0"
+  }
+}