JavaScript Library

const runware = new Runware({ apiKey: "API_KEY" });

const runware = await Runware.initialize({ apiKey: "API_KEY" });

const runware = new RunwareServer({ apiKey: "API_KEY" });

await runware.ensureConnection();

const runware = new RunwareServer({ apiKey: "API_KEY" });

await runware.disconnect();

import { Runware } from "@runware/sdk-js";

const  runware  =  new  Runware({ apiKey: "API_KEY" });
const images = await runware.requestImages({
	positivePrompt: string;
	negativePrompt?: string;
	width: number;
	height: number;
	model: string;
	numberResults?: number;
	outputType?: "URL" | "base64Data" | "dataURI";
	outputFormat?: "JPG" | "PNG" | "WEBP";
	uploadEndpoint?: string;
	checkNSFW?: boolean
	seedImage?: File | string;
	maskImage?: File | string;
	strength?: number;
	steps?: number;
	scheduler?: string;
	seed?: number;
	CFGScale?: number;
	clipSkip?: number;
	refiner?: IRefiner;
	usePromptWeighting?: number;
	controlNet?: IControlNet[];
	lora?: ILora[];
 	retry?: number;
	onPartialImages?: (images: IImage[], error: IError) =>  void;
})

return interface ITextToImage {
	taskType: ETaskType;
	imageUUID: string;
	inputImageUUID?: string;
	taskUUID: string;
	imageURL?: string;
	imageBase64Data?: string;
	imageDataURI?: string;
	NSFWContent?: boolean;
	cost: number;
	positivePrompt?: string;
 	negativePrompt?: string;
}[]

const  runware  =  new Runware({ apiKey: "API_KEY" });
const imageToText = await runware.requestImageToText({
	inputImage: string | File
})
console.log(imageToText)

return interface IImageToText {
  taskType: string;
  taskUUID: string;
  text: string;
  cost?: number;
}

const  runware  =  new Runware({ apiKey: "API_KEY" });
const image = await runware.removeImageBackground({
	inputImage: string | File
	outputType?: IOutputType;
	outputFormat?: IOutputFormat;
	rgba?: number[];
	postProcessMask?: boolean;
	returnOnlyMask?: boolean;
	alphaMatting?: boolean;
	alphaMattingForegroundThreshold?: number;
	alphaMattingBackgroundThreshold?: number;
	alphaMattingErodeSize?: number;
})
console.log(image)
return interface IImage {
	taskType: ETaskType;
	taskUUID: string;
	imageUUID: string;
	inputImageUUID: string;
	imageURL?: string;
	imageBase64Data?: string;
	imageDataURI?: string;
	cost: number;
}

const  runware  =  new Runware({ apiKey: "API_KEY" });
const image = await runware.upscaleGan({
	inputImage: File | string;
	upscaleFactor: number;
	outputType?: IOutputType;
	outputFormat?: IOutputFormat;
	includeCost?: boolean
})
console.log(image)
return interface IImage {
	taskType: ETaskType;
	imageUUID: string;
	inputImageUUID?: string;
	taskUUID: string;
	imageURL?: string;
	imageBase64Data?: string;
	imageDataURI?: string;
	NSFWContent?: boolean;
	cost: number;
}

const  runware  =  new Runware({ apiKey: "API_KEY" });
const enhancedPrompt = await runware.enhancePrompt({
	prompt: string;
	promptMaxLength?: number;
	promptVersions?: number;
	includeCost?: boolean;
})
console.log(enhancedPrompt)
return interface IEnhancedPrompt {
	taskUUID: string;
	text: string;
}

const  runware  =  new Runware({ apiKey: "API_KEY" });
const controlNetPreProcessed = await runware.controlNetPreProcess({
	inputImage: string | File;
	preProcessorType: EPreProcessor;
	height?: number;
	width?: number;
	outputType?: IOutputType;
	outputFormat?: IOutputFormat;
	highThresholdCanny?: number;
	lowThresholdCanny?: number;
	includeHandsAndFaceOpenPose?: boolean;
})
console.log(controlNetPreProcessed)
return interface IControlNetImage {
	taskUUID: string;
	inputImageUUID: string;
	guideImageUUID: string;
	guideImageURL?: string;
	guideImageBase64Data?: string;
	guideImageDataURI?: string;
	cost: number;
}

const  runware  =  new Runware({ apiKey: "API_KEY" });

const basePayload = {
	air: string;
	name: string;
	downloadUrl: string;
	uniqueIdentifier: string;
	version: string;
	format: EModelFormat;
	architecture: EModelArchitecture;
	heroImageUrl?: string;
	tags?: string[];
	shortDescription?: string;
	comment?: string;
	private: boolean;
	customTaskUUID?: string;
	retry?: number;
	onUploadStream?: (
		response?: IAddModelResponse,
		error?: IErrorResponse
	) => void;
}

const controlNetUpload = await runware.modelUpload({
	...basePayload,
 	category: "controlnet";
 	conditioning: EModelConditioning;
})
console.log(controlNetUpload)

const checkpointUpload = await runware.modelUpload({
	...basePayload,
 	category: "checkpoint";
 	positiveTriggerWords?: string;
	defaultCFGScale?: number;
	defaultStrength: number;
	defaultSteps?: number;
	defaultScheduler?: number;
	type?: EModelType;
})
console.log(checkpointUpload)

const loraUpload = await runware.modelUpload({
	...basePayload,
 	category: "lora";
 	defaultWeight: number;
 	positiveTriggerWords?: string;
})

console.log(loraUpload)

return interface IAddModelResponse {
  status: string;
  message: string;
  taskUUID: string;
  air: string;
  taskType: string;
}

export interface IErrorResponse {
  code: string;
  message: string;
  parameter: string;
  type: string;
  documentation: string;
  taskUUID: string;
}

const  runware  =  new Runware({ apiKey: "API_KEY" });

const photoMaker = await runware.modelUpload({
	positivePrompt: string;
	height: number;
	width: number;
	numberResults: number;
	steps?: number;
	inputImages: string[];
	style: EPhotoMakerEnum;
	strength?: number;
	outputFormat?: string;
	includeCost?: boolean;
	customTaskUUID?: string;
	retry?: number;
	onPartialImages?: (images: IImage[], error?: IError) => void
})
console.log(photoMaker)

export interface IImage {
	taskType: ETaskType;
	imageUUID: string;
	inputImageUUID?: string;
	taskUUID: string;
	imageURL?: string;
	imageBase64Data?: string;
	imageDataURI?: string;
	NSFWContent?: boolean;
	cost?: number;
	seed?: number;
}

const  runware  =  new Runware({ apiKey: "API_KEY" });

const modelSearch = await runware.modelSearch({
	search: string;
	tags?: string[];
	category?: "checkpoint" | "lora" | "controlnet";
	architecture?: EModelArchitecture;
	limit?: number;
	offset?: number;
	owned?: boolean;
	featured: boolean;
	type: string;
	conditioning: string;
	private: boolean;
	customTaskUUID?: string;
	retry?: number;
})
console.log(modelSearch)

export type TModelSearchResponse = {
  results: TModel[];
  taskUUID: string;
  taskType: string;
  totalResults: number;
};

export type TModel = {
  name: string;
  air: string;
  downloadUrl: string;
  tags: string[];
  heroImage: string;
  category: string;
  floatingPoint: string;
  private: boolean;
  shortDescription: string;
  comment: string;
  positiveTriggerWords: string;
  defaultSteps: number;
  defaultGuidanceScale: number;
  defaultStrength: number;
  defaultVaeId: number;
  updatedDateUnixTimestamp: number;
  version: string;
  conditioning: string;
  defaultScheduler: string;
  defaultCFG: number;
  format: string;
  uniqueIdentifier: string;
  architecture: string;
  type: string;
  nsfw: boolean;
  sourceUrl: string;
  downloadCount: number;
  nsfwLevel: number;
  rating: number;
  ratingCount: number;
  thumbsUpCount: number;
  thumbsDownCount: number;
  defaultEmaEnable: boolean;
  defaultImageSizeId: string;
  compatibleSizeIds: number[];
};

const  runware  =  new Runware({ apiKey: "API_KEY" });

const imageMasking = await runware.imageMask({
  model: string;
  inputImage: string;
  confidence?: number;
  maskPadding?: number;
  maskBlur?: number;
  outputFormat?: string;
  outputType?: string;
  includeCost?: boolean;
  uploadEndpoint?: string;
  customTaskUUID?: string;
  retry?: number;
})
console.log(imageMasking)

export type TImageMaskingResponse = {
  taskType: string;
  taskUUID: string;
  imageUUID: string;

  detections: [
    {
      x_min: number;
      y_min: number;
      x_max: number;
      y_max: number;
    }
  ];
  maskImageURL: string;
  cost: number;
};