Apidog

Apidog Skill

Comprehensive assistance with Apidog - an all-in-one API development platform for designing, testing, mocking, and documenting APIs.

When to Use This Skill

This skill should be triggered when:

• Designing RESTful APIs or defining endpoints (OpenAPI/Swagger specs)
• Creating API test scenarios and automated testing workflows
• Setting up API mocking for frontend development or testing
• Migrating from Postman, Insomnia, or other API tools
• Working with API documentation generation and sharing
• Debugging API requests and responses
• Managing environments and variables in API workflows
• Writing pre/post processors or test scripts
• Implementing API security schemes (OAuth, API keys, JWT)
• Generating code from API specifications
• Working with schemas and data models (JSON Schema)
• Database operations in API testing (MySQL, MongoDB, Redis)

Quick Reference

Basic API Endpoint Design

{
  "method": "POST",
  "path": "/api/users",
  "parameters": {
    "body": {
      "type": "object",
      "properties": {
        "name": { "type": "string" },
        "email": { "type": "string", "format": "email" }
      },
      "required": ["name", "email"]
    }
  },
  "responses": {
    "201": {
      "description": "User created",
      "body": {
        "type": "object",
        "properties": {
          "id": { "type": "integer" },
          "name": { "type": "string" },
          "email": { "type": "string" }
        }
      }
    }
  }
}

Using Variables in Requests

// Environment variables
{{base_url}}/api/users/{{user_id}}

// Dynamic values
{
  "timestamp": "{{$timestamp}}",
  "uuid": "{{$guid}}",
  "random_email": "{{$randomEmail}}",
  "random_int": "{{$randomInt}}"
}

Post-Processor Script for Extracting Data

// Extract token from response
const response = pm.response.json();
pm.environment.set("auth_token", response.data.token);

// Extract user ID
pm.environment.set("user_id", response.data.user.id);

// Assert response status
pm.test("Status is 200", function() {
  pm.response.to.have.status(200);
});

Basic Assertion Examples

// Status code assertion
pm.test("Status code is 200", function() {
  pm.response.to.have.status(200);
});

// Response body validation
pm.test("Response has user data", function() {
  const jsonData = pm.response.json();
  pm.expect(jsonData).to.have.property('user');
  pm.expect(jsonData.user).to.have.property('email');
});

// Response time check
pm.test("Response time is less than 500ms", function() {
  pm.expect(pm.response.responseTime).to.be.below(500);
});

Setting Up Mock Data

// Smart Mock - Automatically generates data based on field names
{
  "id": "@integer(1, 1000)",
  "name": "@name",
  "email": "@email",
  "avatar": "@image('200x200')",
  "created_at": "@datetime"
}

// Custom Mock with conditions
{
  "status": "@pick(['active', 'pending', 'disabled'])",
  "age": "@integer(18, 65)",
  "balance": "@float(0, 10000, 2, 2)"
}

Pre-Processor Script for Dynamic Headers

// Generate timestamp-based signature
const timestamp = Date.now();
const signature = CryptoJS.MD5(timestamp + "secret_key").toString();

pm.request.headers.add({
  key: "X-Timestamp",
  value: timestamp.toString()
});

pm.request.headers.add({
  key: "X-Signature",
  value: signature
});

Test Scenario with Data Passing

// Step 1: Login and save token
// POST /api/login
pm.test("Login successful", function() {
  const response = pm.response.json();
  pm.environment.set("token", response.access_token);
});

// Step 2: Use token in next request
// GET /api/profile
// Headers: Authorization: Bearer {{token}}

// Step 3: Extract and use profile data
pm.test("Profile fetched", function() {
  const profile = pm.response.json();
  pm.environment.set("user_name", profile.name);
});

Database Operation in Tests

// MySQL query in pre-processor
const db = require('db');
const result = db.query('SELECT * FROM users WHERE email = ?', [pm.environment.get('email')]);
pm.environment.set('user_id', result[0].id);

Schema Composition (oneOf, allOf, anyOf)

{
  "oneOf": [
    {
      "type": "object",
      "properties": {
        "type": { "const": "credit_card" },
        "card_number": { "type": "string" }
      }
    },
    {
      "type": "object",
      "properties": {
        "type": { "const": "bank_account" },
        "account_number": { "type": "string" }
      }
    }
  ]
}

Security Scheme Configuration

{
  "securitySchemes": {
    "BearerAuth": {
      "type": "http",
      "scheme": "bearer",
      "bearerFormat": "JWT"
    },
    "ApiKeyAuth": {
      "type": "apiKey",
      "in": "header",
      "name": "X-API-Key"
    }
  }
}

Key Concepts

Design-First vs Request-First Mode

• Design-First: Define API specifications first, then implement and test
• Request-First: Send requests directly, then optionally save as endpoints
• Apidog supports both workflows seamlessly

Schemas and Components

• Schemas: Reusable data models (JSON Schema format)
• Components: Shared parameters, headers, responses across endpoints
• Enables DRY principles in API design

Smart Mock

Automatically generates realistic mock data based on:

• Field names (email, phone, address, etc.)
• Data types (string, number, boolean)
• Formats (date-time, uuid, url)
• Custom mock rules and priorities

Pre/Post Processors

• Pre-processors: Run before request (setup, auth, dynamic data)
• Post-processors: Run after response (assertions, data extraction, validation)
• Support scripts, database operations, variable extraction, assertions

Test Scenarios

• Chain multiple API requests together
• Pass data between requests using variables
• Add conditional logic and loops
• Generate comprehensive test reports

Environments & Variables

• Environment variables: Configuration per environment (dev, staging, prod)
• Global variables: Shared across all environments
• Temporary variables: Exist only during test scenario execution
• Vault secrets: Secure storage (HashiCorp, Azure, AWS integration)

Reference Files

This skill includes comprehensive documentation in references/:

• api.md - Complete Apidog documentation including:
  • Getting Started: Introduction, navigation, basic concepts, quick start guides
  • Migration: Import from Postman, Insomnia, Swagger/OpenAPI, cURL, HAR files
  • API Design: Endpoint specifications, schemas, components, security schemes, modules
  • Development & Debugging: Requests, responses, environments, variables, code generation
  • Pre/Post Processors: Assertions, scripts, database operations, variable extraction
  • Mock Data: Smart mock, custom mock, mock scripts, cloud vs self-hosted
  • Testing: Test scenarios, automation, reports, data passing between requests
  • Dynamic Values Modules: Faker.js integration for realistic test data (50+ modules)
  • Collaboration: Team management, permissions, version control
  • Documentation: Auto-generation, sharing, customization
  • Integration: CI/CD, webhooks, CLI, API

Use the reference file when you need:

• Detailed feature explanations
• Advanced configuration options
• Migration guides and import procedures
• Comprehensive scripting examples
• Database integration patterns
• Complete dynamic values reference

Working with This Skill

For Beginners

Start with these core concepts:

1. Creating your first endpoint: Define method, path, parameters, and responses
2. Making requests: Use the request panel to test endpoints
3. Basic assertions: Validate status codes and response bodies
4. Environments: Set up dev/staging/prod configurations
5. Mock data: Enable mock server for frontend development

Refer to the Quick Start section in references/api.md for step-by-step tutorials.

For Intermediate Users

Focus on:

1. Schema design: Create reusable data models with JSON Schema
2. Test scenarios: Chain requests and pass data between them
3. Pre/Post processors: Add custom logic with scripts
4. Dynamic values: Use Faker.js modules for realistic test data
5. Security schemes: Implement OAuth, JWT, API key authentication

For Advanced Users

Explore:

1. Database operations: Query MySQL/MongoDB/Redis in tests
2. Custom scripts: Use JavaScript libraries and external languages
3. Schema composition: Leverage oneOf, allOf, anyOf for complex models
4. CI/CD integration: Automate testing in pipelines
5. Team collaboration: Version control, branches, merge conflicts
6. API documentation: Customize and publish interactive docs

For Migration

If coming from other tools:

• Postman users: Import collections, environments, and globals
• Insomnia users: Import workspaces and requests
• Swagger users: Import OpenAPI 2.0/3.0 specifications
• cURL users: Paste cURL commands directly
• Check references/api.md Migration section for detailed guides

Navigation Tips

• Use Ctrl/Cmd+K for quick search across documentation
• Check the Table of Contents in api.md for specific topics
• Dynamic Values Modules section lists all available Faker.js functions
• Script examples section shows common patterns for assertions and data manipulation

Common Workflows

Workflow 1: Design → Mock → Test → Document

1. Design API endpoints with schemas
2. Enable smart mock for realistic data
3. Write test scenarios with assertions
4. Auto-generate and share documentation

Workflow 2: Import → Enhance → Automate

1. Import from Postman/Swagger
2. Add schemas and components for reusability
3. Create test scenarios with data passing
4. Integrate with CI/CD pipeline

Workflow 3: Request-First Development

1. Send ad-hoc requests to explore APIs
2. Save successful requests as endpoints
3. Add schemas from response bodies
4. Build test scenarios from saved requests

Resources

Official Documentation

All content is sourced from https://docs.apidog.com/

Dynamic Values Reference

Apidog includes 50+ Faker.js modules for test data:

• Person (names, emails, phones)
• Internet (URLs, IPs, domains)
• Commerce (products, prices)
• Date/Time (timestamps, future/past dates)
• Location (addresses, coordinates)
• Finance (credit cards, transactions)
• And many more - see Dynamic Values Modules in api.md

Database Support

• MySQL / PostgreSQL
• MongoDB
• Redis
• Oracle

Scripting Languages

• JavaScript (primary)
• Python, PHP, Go, Java (via external execution)

Import/Export Formats

• OpenAPI 2.0 / 3.0
• Postman Collection v1/v2
• Insomnia v4
• HAR (HTTP Archive)
• cURL
• WSDL
• Markdown

Notes

• This skill was automatically generated from official Apidog documentation
• Code examples preserve syntax from source docs with proper language detection
• Quick reference examples are extracted from real-world usage patterns
• Reference file maintains hierarchical structure of official documentation

Updating

To refresh this skill with updated documentation:

1. Re-run the scraper with the same configuration
2. The skill will be rebuilt with the latest information from docs.apidog.com